@getpaseo/server 0.1.89 → 0.1.91-beta.1

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

package/dist/server/server/atomic-file.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function writeFileAtomic(filePath, data) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(tempPath, data, "utf8");
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true });
+        throw error;
+    }
+}
+export async function writeJsonFileAtomic(filePath, value) {
+    await writeFileAtomic(filePath, JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=atomic-file.js.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.js

@@ -34,7 +34,10 @@ export async function archiveIfSafe(input) {
         if (!snapshot) {
             return;
         }
-        if (snapshot.git.isDirty === true || (snapshot.git.aheadOfOrigin ?? 0) > 0) {
+        if (snapshot.git.isDirty === true || snapshot.git.aheadOfOrigin === null) {
+            return;
+        }
+        if (snapshot.git.aheadOfOrigin > 0) {
             return;
         }
         const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, {

package/dist/server/server/bootstrap.js

@@ -418,6 +418,7 @@ export async function createPaseoDaemon(config, rootLogger) {
         paseoHome: config.paseoHome,
         logger,
         agentManager,
+        providerSnapshotManager,
     });
     await loopService.initialize();
     logger.info({ elapsed: elapsed() }, "Loop service initialized");
@@ -426,6 +427,7 @@ export async function createPaseoDaemon(config, rootLogger) {
         logger,
         agentManager,
         agentStorage,
+        providerSnapshotManager,
     });
     await scheduleService.start();
     agentManager.setAgentArchivedCallback(async (agentId) => {

package/dist/server/server/chat/chat-service.js

@@ -2,6 +2,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 { ChatMessageSchema, ChatRoomDetailSchema, ChatRoomSchema, } from "@getpaseo/protocol/chat/types";
 const ChatStorePayloadSchema = z.object({
     rooms: z.array(ChatRoomSchema),
@@ -246,10 +247,7 @@ export class FileBackedChatService {
                 .flat()
                 .sort((left, right) => left.createdAt.localeCompare(right.createdAt)),
         };
-        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
-        const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
-        await fs.writeFile(tempPath, JSON.stringify(payload, null, 2), "utf8");
-        await fs.rename(tempPath, this.filePath);
+        await writeJsonFileAtomic(this.filePath, payload);
     }
     findRoomByName(name) {
         const normalizedName = normalizeRoomName(name);

package/dist/server/server/daemon-keypair.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
 import { generateKeyPair, exportPublicKey, exportSecretKey, importPublicKey, importSecretKey, } from "@getpaseo/relay/e2ee";
-import { ensurePrivateFile, writePrivateFileSync } from "./private-files.js";
+import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
 const KeyPairSchema = z.object({
     v: z.literal(2),
     publicKeyB64: z.string().min(1),
@@ -35,7 +35,7 @@ export async function loadOrCreateDaemonKeyPair(paseoHome, logger) {
         publicKeyB64,
         secretKeyB64,
     };
-    writePrivateFileSync(filePath, JSON.stringify(payload, null, 2) + "\n");
+    writePrivateFileAtomicSync(filePath, JSON.stringify(payload, null, 2) + "\n");
     log?.info({ filePath }, "Saved daemon keypair");
     return { keyPair, publicKeyB64 };
 }

package/dist/server/server/loop-service.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import type { Logger } from "pino";
 import type { AgentManager } from "./agent/agent-manager.js";
 import type { AgentProvider } from "./agent/agent-sdk-types.js";
+import type { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
 declare const LoopLogEntrySchema: z.ZodObject<{
     seq: z.ZodNumber;
     timestamp: z.ZodString;
@@ -493,6 +494,7 @@ export interface LoopLogsResult {
     entries: LoopLogEntry[];
     nextCursor: number;
 }
+type CreateConfigResolver = Pick<ProviderSnapshotManager, "resolveCreateConfig">;
 export declare class LoopService {
     private readonly options;
     private readonly storePath;
@@ -505,6 +507,7 @@ export declare class LoopService {
         paseoHome: string;
         agentManager: AgentManager;
         logger: Logger;
+        providerSnapshotManager: CreateConfigResolver;
     });
     initialize(): Promise<void>;
     runLoop(input: LoopRunOptions): Promise<LoopRecord>;
@@ -518,6 +521,7 @@ export declare class LoopService {
     private runVerification;
     private buildWorkerConfig;
     private buildVerifierConfig;
+    private resolveProviderCreateConfig;
     private resolveFinalText;
     private toPrompt;
     private finishLoop;

package/dist/server/server/loop-service.js

@@ -2,10 +2,10 @@ 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 { curateAgentActivity } from "./agent/activity-curator.js";
 import { getStructuredAgentResponse } from "./agent/agent-response-loop.js";
 import { execCommand, platformShell } from "../utils/spawn.js";
-import { getUnattendedModeId } from "@getpaseo/protocol/provider-manifest";
 const LOOP_ID_LENGTH = 8;
 const DEFAULT_LOOP_PROVIDER = "claude";
 const MAX_VERIFY_OUTPUT_BYTES = 64 * 1024;
@@ -494,7 +494,7 @@ export class LoopService {
         await this.persist();
     }
     async runWorkerIteration(loop, iteration, signal) {
-        const agent = await this.options.agentManager.createAgent(this.buildWorkerConfig(loop, iteration));
+        const agent = await this.options.agentManager.createAgent(await this.buildWorkerConfig(loop, iteration));
         iteration.workerAgentId = agent.id;
         loop.activeWorkerAgentId = agent.id;
         loop.updatedAt = nowIso();
@@ -591,7 +591,7 @@ export class LoopService {
             return true;
         }
         const startedAt = nowIso();
-        const verifierAgent = await this.options.agentManager.createAgent(this.buildVerifierConfig(loop, iteration));
+        const verifierAgent = await this.options.agentManager.createAgent(await this.buildVerifierConfig(loop, iteration));
         iteration.verifierAgentId = verifierAgent.id;
         loop.activeVerifierAgentId = verifierAgent.id;
         loop.updatedAt = nowIso();
@@ -659,28 +659,47 @@ export class LoopService {
             }
         }
     }
-    buildWorkerConfig(loop, iteration) {
+    async buildWorkerConfig(loop, iteration) {
         const provider = loop.workerProvider ?? loop.provider;
+        const resolvedUnattendedConfig = loop.modeId
+            ? { modeId: loop.modeId, featureValues: undefined }
+            : await this.resolveProviderCreateConfig({ provider, cwd: loop.cwd });
         return {
             provider,
             cwd: loop.cwd,
             model: loop.workerModel ?? loop.model ?? undefined,
-            modeId: loop.modeId ?? getUnattendedModeId(provider),
+            modeId: resolvedUnattendedConfig.modeId,
+            featureValues: resolvedUnattendedConfig.featureValues,
             title: buildWorkerTitle(loop, iteration.index),
             internal: true,
         };
     }
-    buildVerifierConfig(loop, iteration) {
+    async buildVerifierConfig(loop, iteration) {
         const provider = loop.verifierProvider ?? loop.provider;
+        const explicitModeId = loop.verifierModeId ?? loop.modeId;
+        const resolvedUnattendedConfig = explicitModeId
+            ? { modeId: explicitModeId, featureValues: undefined }
+            : await this.resolveProviderCreateConfig({ provider, cwd: loop.cwd });
         return {
             provider,
             cwd: loop.cwd,
             model: loop.verifierModel ?? loop.model ?? undefined,
-            modeId: loop.verifierModeId ?? loop.modeId ?? getUnattendedModeId(provider),
+            modeId: resolvedUnattendedConfig.modeId,
+            featureValues: resolvedUnattendedConfig.featureValues,
             title: buildVerifierTitle(loop, iteration.index),
             internal: true,
         };
     }
+    resolveProviderCreateConfig(input) {
+        return this.options.providerSnapshotManager.resolveCreateConfig({
+            provider: input.provider,
+            cwd: input.cwd,
+            requestedMode: undefined,
+            featureValues: undefined,
+            parent: null,
+            unattended: true,
+        });
+    }
     resolveFinalText(timeline, finalText) {
         if (finalText.trim()) {
             return finalText;
@@ -739,9 +758,8 @@ export class LoopService {
     }
     async persist() {
         const nextPersist = this.persistQueue.then(async () => {
-            await fs.mkdir(path.dirname(this.storePath), { recursive: true });
             const records = Array.from(this.loops.values()).sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-            await fs.writeFile(this.storePath, JSON.stringify(records, null, 2), "utf8");
+            await writeJsonFileAtomic(this.storePath, records);
             return;
         });
         this.persistQueue = nextPersist.catch(() => { });

package/dist/server/server/persisted-config.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
 import { AgentProviderRuntimeSettingsMapSchema, migrateProviderSettings, ProviderOverridesSchema, } from "./agent/provider-launch-config.js";
-import { ensurePrivateFile, writePrivateFileSync } from "./private-files.js";
+import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
 export const LogLevelSchema = z.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
 export const LogFormatSchema = z.enum(["pretty", "json"]);
 const LogConfigSchema = z
@@ -296,7 +296,7 @@ export function loadPersistedConfig(paseoHome, logger) {
     const configPath = getConfigPath(paseoHome);
     if (!existsSync(configPath)) {
         try {
-            writePrivateFileSync(configPath, JSON.stringify(DEFAULT_PERSISTED_CONFIG, null, 2) + "\n");
+            writePrivateFileAtomicSync(configPath, JSON.stringify(DEFAULT_PERSISTED_CONFIG, null, 2) + "\n");
             log?.info(`Initialized config file at ${configPath}`);
         }
         catch (err) {
@@ -347,7 +347,7 @@ export function savePersistedConfig(paseoHome, config, logger) {
         throw new Error(`[Config] Invalid config to save:\n${issues}`);
     }
     try {
-        writePrivateFileSync(configPath, JSON.stringify(result.data, null, 2) + "\n");
+        writePrivateFileAtomicSync(configPath, JSON.stringify(result.data, null, 2) + "\n");
         log?.info(`Saved to ${configPath}`);
     }
     catch (err) {

package/dist/server/server/private-files.d.ts

@@ -2,6 +2,5 @@ export declare const PRIVATE_DIRECTORY_MODE = 448;
 export declare const PRIVATE_FILE_MODE = 384;
 export declare function ensurePrivateDirectory(directoryPath: string): void;
 export declare function ensurePrivateFile(filePath: string): void;
-export declare function writePrivateFileSync(filePath: string, data: string | NodeJS.ArrayBufferView): void;
 export declare function writePrivateFileAtomicSync(filePath: string, data: string | NodeJS.ArrayBufferView): void;
 //# sourceMappingURL=private-files.d.ts.map

package/dist/server/server/private-files.js

@@ -21,11 +21,6 @@ export function ensurePrivateDirectory(directoryPath) {
 export function ensurePrivateFile(filePath) {
     chmodBestEffort(filePath, PRIVATE_FILE_MODE);
 }
-export function writePrivateFileSync(filePath, data) {
-    ensurePrivateDirectory(path.dirname(filePath));
-    writeFileSync(filePath, data, { mode: PRIVATE_FILE_MODE });
-    ensurePrivateFile(filePath);
-}
 export function writePrivateFileAtomicSync(filePath, data) {
     ensurePrivateDirectory(path.dirname(filePath));
     const tmpPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);

package/dist/server/server/schedule/service.d.ts

@@ -1,12 +1,15 @@
 import type { Logger } from "pino";
 import { AgentManager } from "../agent/agent-manager.js";
 import type { AgentStorage } from "../agent/agent-storage.js";
+import type { ProviderSnapshotManager } from "../agent/provider-snapshot-manager.js";
 import type { CreateScheduleInput, ScheduleExecutionResult, ScheduleRun, StoredSchedule, UpdateScheduleInput } from "@getpaseo/protocol/schedule/types";
+type CreateConfigResolver = Pick<ProviderSnapshotManager, "resolveCreateConfig">;
 export interface ScheduleServiceOptions {
     paseoHome: string;
     logger: Logger;
     agentManager: AgentManager;
     agentStorage: AgentStorage;
+    providerSnapshotManager: CreateConfigResolver;
     now?: () => Date;
     runner?: (schedule: StoredSchedule, runId: string) => Promise<ScheduleExecutionResult>;
 }
@@ -15,6 +18,7 @@ export declare class ScheduleService {
     private readonly logger;
     private readonly agentManager;
     private readonly agentStorage;
+    private readonly createConfigResolver;
     private readonly now;
     private readonly runner;
     private readonly runningScheduleIds;
@@ -37,5 +41,7 @@ export declare class ScheduleService {
     private runSchedule;
     private finishRun;
     private executeSchedule;
+    private resolveProviderCreateConfig;
 }
+export {};
 //# sourceMappingURL=service.d.ts.map

package/dist/server/server/schedule/service.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { curateAgentActivity } from "../agent/activity-curator.js";
 import { ensureAgentLoaded } from "../agent/agent-loading.js";
 import { formatSystemNotificationPrompt } from "../agent/agent-prompt.js";
-import { getUnattendedModeId } from "@getpaseo/protocol/provider-manifest";
+import { resolveCreateAgentTitles } from "../agent/create-agent-title.js";
 import { ScheduleStore } from "./store.js";
 import { computeNextRunAt, validateScheduleCadence } from "./cron.js";
 const SCHEDULE_TICK_INTERVAL_MS = 1000;
@@ -113,6 +113,7 @@ export class ScheduleService {
         this.logger = options.logger.child({ module: "schedule-service" });
         this.agentManager = options.agentManager;
         this.agentStorage = options.agentStorage;
+        this.createConfigResolver = options.providerSnapshotManager;
         this.now = options.now ?? (() => new Date());
         this.runner = options.runner ?? ((schedule, runId) => this.executeSchedule(schedule, runId));
     }
@@ -418,8 +419,8 @@ export class ScheduleService {
         await this.store.put(updated);
     }
     async executeSchedule(schedule, runId) {
-        const wrappedPrompt = formatSystemNotificationPrompt(buildScheduleFireBody(schedule, runId));
         if (schedule.target.type === "agent") {
+            const wrappedPrompt = formatSystemNotificationPrompt(buildScheduleFireBody(schedule, runId));
             const record = await this.agentStorage.get(schedule.target.agentId);
             if (record?.archivedAt) {
                 throw new Error(`Agent ${schedule.target.agentId} is archived`);
@@ -443,30 +444,49 @@ export class ScheduleService {
                 }),
             };
         }
+        const targetConfig = schedule.target.config;
+        const resolvedUnattendedConfig = targetConfig.modeId
+            ? { modeId: targetConfig.modeId, featureValues: targetConfig.featureValues }
+            : await this.resolveProviderCreateConfig({
+                provider: targetConfig.provider,
+                cwd: targetConfig.cwd,
+                requestedMode: undefined,
+                featureValues: targetConfig.featureValues,
+                parent: null,
+                unattended: true,
+            });
         const config = {
-            provider: schedule.target.config.provider,
-            cwd: schedule.target.config.cwd,
-            modeId: schedule.target.config.modeId ?? getUnattendedModeId(schedule.target.config.provider),
-            model: schedule.target.config.model,
-            thinkingOptionId: schedule.target.config.thinkingOptionId,
-            title: schedule.target.config.title,
-            approvalPolicy: schedule.target.config.approvalPolicy,
-            sandboxMode: schedule.target.config.sandboxMode,
-            networkAccess: schedule.target.config.networkAccess,
-            webSearch: schedule.target.config.webSearch,
-            featureValues: schedule.target.config.featureValues,
-            extra: schedule.target.config.extra,
-            systemPrompt: schedule.target.config.systemPrompt,
-            mcpServers: schedule.target.config.mcpServers,
+            provider: targetConfig.provider,
+            cwd: targetConfig.cwd,
+            modeId: resolvedUnattendedConfig.modeId,
+            model: targetConfig.model,
+            thinkingOptionId: targetConfig.thinkingOptionId,
+            title: targetConfig.title,
+            approvalPolicy: targetConfig.approvalPolicy,
+            sandboxMode: targetConfig.sandboxMode,
+            networkAccess: targetConfig.networkAccess,
+            webSearch: targetConfig.webSearch,
+            featureValues: resolvedUnattendedConfig.featureValues,
+            extra: targetConfig.extra,
+            systemPrompt: targetConfig.systemPrompt,
+            mcpServers: targetConfig.mcpServers,
         };
+        const { provisionalTitle } = resolveCreateAgentTitles({
+            configTitle: config.title,
+            initialPrompt: schedule.prompt,
+        });
         const labels = {
             "paseo.schedule-id": schedule.id,
             "paseo.schedule-run": runId,
         };
-        const agent = await this.agentManager.createAgent(config, undefined, { labels });
+        const agent = await this.agentManager.createAgent(config, undefined, {
+            labels,
+            initialPrompt: schedule.prompt,
+            initialTitle: provisionalTitle,
+        });
         let result;
         try {
-            result = await this.agentManager.runAgent(agent.id, wrappedPrompt);
+            result = await this.agentManager.runAgent(agent.id, schedule.prompt);
         }
         catch (error) {
             try {
@@ -488,5 +508,8 @@ export class ScheduleService {
             }),
         };
     }
+    async resolveProviderCreateConfig(input) {
+        return this.createConfigResolver.resolveCreateConfig(input);
+    }
 }
 //# sourceMappingURL=service.js.map

package/dist/server/server/schedule/store.js

@@ -1,7 +1,8 @@
 import { randomBytes } from "node:crypto";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { StoredScheduleSchema } from "@getpaseo/protocol/schedule/types";
+import { writeJsonFileAtomic } from "../atomic-file.js";
 function generateScheduleId() {
     return randomBytes(4).toString("hex");
 }
@@ -46,7 +47,7 @@ export class ScheduleStore {
     }
     async put(schedule) {
         await this.ensureDir();
-        await writeFile(this.filePath(schedule.id), JSON.stringify(schedule, null, 2), "utf-8");
+        await writeJsonFileAtomic(this.filePath(schedule.id), schedule);
     }
     async delete(id) {
         await this.ensureDir();

package/dist/server/server/server-id.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { ensurePrivateFile, writePrivateFileSync } from "./private-files.js";
+import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
 const SERVER_ID_FILENAME = "server-id";
 function getLogger(logger) {
     return logger?.child({ module: "server-id" });
@@ -31,7 +31,7 @@ export function getOrCreateServerId(paseoHome, options) {
         // Persist the override for consistent identity across restarts.
         if (!existsSync(serverIdPath)) {
             try {
-                writePrivateFileSync(serverIdPath, `${envOverride}\n`);
+                writePrivateFileAtomicSync(serverIdPath, `${envOverride}\n`);
                 log?.info({ serverId: envOverride }, "Persisted PASEO_SERVER_ID override");
             }
             catch (error) {
@@ -58,7 +58,7 @@ export function getOrCreateServerId(paseoHome, options) {
     }
     const created = generateServerId();
     try {
-        writePrivateFileSync(serverIdPath, `${created}\n`);
+        writePrivateFileAtomicSync(serverIdPath, `${created}\n`);
     }
     catch (error) {
         log?.warn({ error }, "Failed to persist serverId (continuing with in-memory id)");

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

@@ -1,5 +1,5 @@
 import { type ClientCapability } from "@getpaseo/protocol/client-capabilities";
-import { type AgentSnapshotPayload, type SessionInboundMessage, type SessionOutboundMessage, type EditorTargetDescriptorPayload, type EditorTargetId, type WorkspaceSetupSnapshot } from "./messages.js";
+import { type AgentSnapshotPayload, type SessionInboundMessage, type SessionOutboundMessage, type WorkspaceSetupSnapshot } from "./messages.js";
 import type { TerminalManager } from "../terminal/terminal-manager.js";
 import { type TerminalStreamFrame } from "@getpaseo/protocol/binary-frames/index";
 import type { SpeechToTextProvider, TextToSpeechProvider } from "./speech/speech-provider.js";
@@ -176,8 +176,6 @@ export declare class Session {
     private readonly terminalController;
     private inflightRequests;
     private peakInflightRequests;
-    private readonly availableEditorTargetsCache;
-    private readonly getMemoizedAvailableEditorTargets;
     private readonly checkoutDiffSubscriptions;
     private readonly workspaceGitWatchTargets;
     private readonly workspaceSetupSnapshots;
@@ -254,7 +252,6 @@ export declare class Session {
     private buildAgentPayload;
     private buildStoredAgentPayload;
     private isProviderVisibleToClient;
-    private filterEditorsForClient;
     private agentThinkingOptionMatchesFilter;
     private matchesAgentStructuralFilter;
     private matchesAgentFilter;
@@ -471,27 +468,20 @@ export declare class Session {
     private handleFetchAgentHistory;
     private handleFetchRecentProviderSessions;
     private handleFetchWorkspacesRequest;
+    private buildBootstrapSnapshot;
     private registerWorkspaceForImportedAgent;
     private handleOpenProjectRequest;
     private buildWorkspaceScriptPayloadSnapshot;
     private resolveWorkspaceScriptGitMetadata;
     private emitWorkspaceScriptStatusUpdate;
-    resolveAvailableEditorTargets(): Promise<EditorTargetDescriptorPayload[]>;
-    getAvailableEditorTargets(): Promise<{
-        id: string;
-        label: string;
-    }[]>;
-    openEditorTarget(options: {
-        editorId: EditorTargetId;
-        path: string;
-    }): Promise<void>;
     private handleStartWorkspaceScriptRequest;
-    private handleListAvailableEditorsRequest;
-    private handleOpenInEditorRequest;
+    private handleLegacyListAvailableEditorsRequest;
+    private handleLegacyOpenInEditorRequest;
     private handleCreatePaseoWorktreeRequest;
     private createPaseoWorktreeWorkflow;
     private handleWorkspaceSetupStatusRequest;
     private handleArchiveWorkspaceRequest;
+    private handleWorkspaceClearAttentionRequest;
     private handleFetchAgent;
     private shouldUseFullTimelineForProjectedPage;
     private selectCanonicalTimelineProjection;