@getpaseo/server 0.1.97-beta.1 → 0.1.97-beta.3

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

@@ -1,3 +1,4 @@
+import type { FirstAgentContext } from "@getpaseo/protocol/messages";
 export declare function resolveCreateAgentTitles(options: {
     configTitle?: string | null;
     initialPrompt?: string | null;
@@ -5,4 +6,5 @@ export declare function resolveCreateAgentTitles(options: {
     explicitTitle: string | null;
     provisionalTitle: string | null;
 };
+export declare function resolveFirstAgentPromptTitle(firstAgentContext?: FirstAgentContext): string | null;
 //# sourceMappingURL=create-agent-title.d.ts.map

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

@@ -26,4 +26,9 @@ export function resolveCreateAgentTitles(options) {
         provisionalTitle,
     };
 }
+export function resolveFirstAgentPromptTitle(firstAgentContext) {
+    return (resolveCreateAgentTitles({
+        initialPrompt: firstAgentContext?.prompt,
+    }).provisionalTitle ?? null);
+}
 //# sourceMappingURL=create-agent-title.js.map

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

@@ -102,6 +102,7 @@ export declare class ProviderSnapshotManager {
     private reconcileSnapshotForRegistry;
     private warmUp;
     private refreshProviders;
+    private resolveProvidersToWarm;
     private clearCachedProviders;
     private loadProviders;
     private loadProvider;

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

@@ -43,31 +43,11 @@ export class ProviderSnapshotManager {
     }
     getSnapshot(cwd) {
         const resolvedCwd = resolveSnapshotCwd(cwd);
-        const entries = this.snapshots.get(resolvedCwd);
-        if (!entries) {
-            const loadingEntries = this.resetSnapshotToLoading(resolvedCwd);
-            void this.warmUp(resolvedCwd);
-            return entriesToArray(loadingEntries);
+        const providersToWarm = this.resolveProvidersToWarm(resolvedCwd);
+        if (providersToWarm.length > 0) {
+            void this.warmUp(resolvedCwd, providersToWarm);
         }
-        const missingProviders = this.getProviderIds().filter((provider) => !entries.has(provider));
-        if (missingProviders.length > 0) {
-            const loadingEntries = this.createLoadingEntries();
-            for (const provider of missingProviders) {
-                const loadingEntry = loadingEntries.get(provider);
-                if (loadingEntry) {
-                    entries.set(provider, loadingEntry);
-                }
-            }
-            void this.warmUp(resolvedCwd, missingProviders);
-        }
-        const providerLoads = this.providerLoads.get(resolvedCwd);
-        const loadingProviders = Array.from(entries.values())
-            .filter((entry) => entry.status === "loading" && !providerLoads?.has(entry.provider))
-            .map((entry) => entry.provider);
-        if (loadingProviders.length > 0) {
-            void this.warmUp(resolvedCwd, loadingProviders);
-        }
-        return entriesToArray(entries);
+        return entriesToArray(this.getOrCreateSnapshot(resolvedCwd));
     }
     async refreshSnapshotForCwd(options) {
         const snapshotCwd = resolveSnapshotCwd(options.cwd);
@@ -91,17 +71,11 @@ export class ProviderSnapshotManager {
         if (options.providers && providers?.length === 0) {
             return;
         }
-        const snapshot = this.snapshots.get(snapshotCwd);
-        if (!snapshot) {
-            this.resetSnapshotToLoading(snapshotCwd, providers);
-        }
-        else if (providers) {
-            const missingProviders = providers.filter((provider) => !snapshot.has(provider));
-            if (missingProviders.length > 0) {
-                this.resetSnapshotToLoading(snapshotCwd, missingProviders);
-            }
+        const providersToWarm = this.resolveProvidersToWarm(snapshotCwd, providers);
+        if (providersToWarm.length === 0) {
+            return;
         }
-        await this.warmUp(snapshotCwd, providers);
+        await this.warmUp(snapshotCwd, providersToWarm);
     }
     async refresh(options) {
         await this.refreshSnapshotForCwd(options);
@@ -355,6 +329,19 @@ export class ProviderSnapshotManager {
     async refreshProviders(cwd, providers) {
         await this.loadProviders({ cwd, providers, force: true });
     }
+    resolveProvidersToWarm(cwd, providers) {
+        const providersToInspect = providers ?? this.getProviderIds();
+        const snapshot = this.snapshots.get(cwd);
+        if (!snapshot) {
+            this.resetSnapshotToLoading(cwd, providers);
+            return providersToInspect;
+        }
+        const missingProviders = providersToInspect.filter((provider) => !snapshot.has(provider));
+        if (missingProviders.length > 0) {
+            this.resetSnapshotToLoading(cwd, missingProviders);
+        }
+        return providersToInspect.filter((provider) => snapshot.get(provider)?.status === "loading");
+    }
     clearCachedProviders(providers) {
         const providerSet = providers ? new Set(providers) : null;
         const loadingEntries = this.createLoadingEntries();
@@ -404,6 +391,10 @@ export class ProviderSnapshotManager {
         if (existingLoad && !options.force) {
             return existingLoad.promise;
         }
+        const existingEntry = this.snapshots.get(options.cwd)?.get(options.provider);
+        if (existingEntry && existingEntry.status !== "loading" && !options.force) {
+            return Promise.resolve();
+        }
         const load = {
             promise: Promise.resolve(),
         };

package/dist/server/server/bootstrap.js

@@ -6,7 +6,6 @@ import { randomUUID } from "node:crypto";
 import { hostname as getHostname } from "node:os";
 import path from "node:path";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { createBranchChangeRouteHandler } from "./script-route-branch-handler.js";
 function resolveBoundListenTarget(listenTarget, httpServer) {
@@ -587,8 +586,7 @@ export async function createPaseoDaemon(config, rootLogger) {
     let agentMcpBaseUrl = null;
     if (mcpEnabled) {
         const agentMcpRoute = "/mcp/agents";
-        const agentMcpTransports = new Map();
-        const createAgentMcpTransport = async (callerAgentId) => {
+        const createAgentMcpSession = async (callerAgentId) => {
             const agentMcpServer = await createAgentMcpServer({
                 agentManager,
                 agentStorage,
@@ -651,32 +649,24 @@ export async function createPaseoDaemon(config, rootLogger) {
                 resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
                 logger,
             });
+            // Stateless mode: each HTTP request builds a fresh server + transport that is
+            // torn down when the response closes, so no per-session state is retained between
+            // requests. The agent control plane only lists and calls tools, neither of which
+            // needs cross-request state, so sessions would only pin memory for the life of the
+            // daemon (agents that exit without a clean DELETE never get reaped).
             const transport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: () => randomUUID(),
-                onsessioninitialized: (sessionId) => {
-                    agentMcpTransports.set(sessionId, transport);
-                    logger.debug({ sessionId }, "Agent MCP session initialized");
-                },
-                onsessionclosed: (sessionId) => {
-                    agentMcpTransports.delete(sessionId);
-                    logger.debug({ sessionId }, "Agent MCP session closed");
-                },
+                sessionIdGenerator: undefined,
                 // NOTE: We enforce a Vite-like host allowlist at the app/websocket layer.
                 // StreamableHTTPServerTransport's built-in check requires exact Host header matches.
                 enableDnsRebindingProtection: false,
             });
             Object.assign(transport, {
-                onclose: () => {
-                    if (transport.sessionId) {
-                        agentMcpTransports.delete(transport.sessionId);
-                    }
-                },
                 onerror: (err) => {
                     logger.error({ err }, "Agent MCP transport error");
                 },
             });
             await agentMcpServer.connect(transport);
-            return transport;
+            return { server: agentMcpServer, transport };
         };
         const runAgentMcpRequest = async (req, res) => {
             // This route is exempt from the global daemon-password middleware, so it
@@ -701,41 +691,33 @@ export async function createPaseoDaemon(config, rootLogger) {
                 }, "Agent MCP request");
             }
             try {
-                const sessionId = req.header("mcp-session-id");
-                let transport = sessionId ? agentMcpTransports.get(sessionId) : undefined;
-                if (!transport) {
-                    if (req.method !== "POST") {
-                        res.status(400).json({
-                            jsonrpc: "2.0",
-                            error: {
-                                code: -32000,
-                                message: "Missing or invalid MCP session",
-                            },
-                            id: null,
-                        });
-                        return;
-                    }
-                    if (!isInitializeRequest(req.body)) {
-                        res.status(400).json({
-                            jsonrpc: "2.0",
-                            error: {
-                                code: -32000,
-                                message: "Initialization request expected",
-                            },
-                            id: null,
-                        });
-                        return;
-                    }
-                    const callerAgentIdRaw = req.query.callerAgentId;
-                    let callerAgentId;
-                    if (typeof callerAgentIdRaw === "string") {
-                        callerAgentId = callerAgentIdRaw;
-                    }
-                    else if (Array.isArray(callerAgentIdRaw) && typeof callerAgentIdRaw[0] === "string") {
-                        callerAgentId = callerAgentIdRaw[0];
-                    }
-                    transport = await createAgentMcpTransport(callerAgentId);
+                // Stateless: GET (standalone SSE) and DELETE (session termination) have no
+                // meaning without sessions. The MCP client tolerates 405 on the GET stream
+                // and never issues a DELETE because it is never handed a session id.
+                if (req.method !== "POST") {
+                    res.status(405).json({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32000,
+                            message: "Method not allowed",
+                        },
+                        id: null,
+                    });
+                    return;
+                }
+                const callerAgentIdRaw = req.query.callerAgentId;
+                let callerAgentId;
+                if (typeof callerAgentIdRaw === "string") {
+                    callerAgentId = callerAgentIdRaw;
                 }
+                else if (Array.isArray(callerAgentIdRaw) && typeof callerAgentIdRaw[0] === "string") {
+                    callerAgentId = callerAgentIdRaw[0];
+                }
+                const { server, transport } = await createAgentMcpSession(callerAgentId);
+                res.on("close", () => {
+                    void transport.close();
+                    void server.close();
+                });
                 await transport.handleRequest(req, res, req.body);
             }
             catch (err) {

package/dist/server/server/paseo-worktree-service.js

@@ -5,6 +5,7 @@ import { createWorktreeCore, } from "./worktree-core.js";
 import { validateBranchSlug } from "../utils/worktree.js";
 import { getCurrentBranch, localBranchExists, renameCurrentBranch } from "../utils/checkout-git.js";
 import { markPaseoWorktreeFirstAgentBranchAutoNameAttempted, readPaseoWorktreeMetadata, writePaseoWorktreeFirstAgentBranchAutoNameMetadata, } from "../utils/worktree-metadata.js";
+import { resolveFirstAgentPromptTitle } from "./agent/create-agent-title.js";
 import { buildAgentBranchNameSeed } from "./agent/prompt-attachments.js";
 export async function createPaseoWorktree(input, deps) {
     const createdWorktree = await createWorktreeCore(input, deps);
@@ -14,6 +15,7 @@ export async function createPaseoWorktree(input, deps) {
         projectId: input.projectId,
         repoRoot: createdWorktree.repoRoot,
         worktree: createdWorktree.worktree,
+        title: resolveFirstAgentPromptTitle(input.firstAgentContext),
         deps,
     });
     deps.github.invalidate({ cwd: createdWorktree.worktree.worktreePath });
@@ -140,6 +142,7 @@ async function upsertWorkspaceForWorktree(options) {
         kind: "worktree",
         displayName: options.worktree.branchName || normalizedCwd,
         branch: options.worktree.branchName || null,
+        title: options.title ?? null,
         createdAt: now,
         updatedAt: now,
         archivedAt: null,

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

@@ -345,6 +345,7 @@ export declare class Session {
     private scheduleAutoNameWorkspaceBranchForFirstAgent;
     private maybeAutoNameWorkspaceBranchForFirstAgent;
     private applyGeneratedWorkspaceTitle;
+    private writeInitialWorkspaceTitleIfUntitled;
     private generateWorkspaceTitleFromContext;
     private maybeAutoNameDirectoryWorkspaceTitle;
     private scheduleAutoNameLocalWorkspaceTitleForFirstAgent;
@@ -479,6 +480,7 @@ export declare class Session {
     private bufferOrEmitWorkspaceUpdate;
     private flushBootstrappedWorkspaceUpdates;
     private findOrCreateWorkspaceForDirectory;
+    private resolveOrCreateWorkspaceIdForCreateAgent;
     private createWorkspaceForDirectory;
     private reclassifyOrUnarchiveWorkspaceForDirectory;
     private resolveProjectRecordForPlacement;

package/dist/server/server/session.js

@@ -23,7 +23,7 @@ import { createVoiceTurnController, } from "./voice/voice-turn-controller.js";
 import { buildConfigOverrides, extractTimestamps, isStoredAgentProviderAvailable, toAgentPersistenceHandle, } from "./persistence-hooks.js";
 import { ensureAgentLoaded } from "./agent/agent-loading.js";
 import { formatSystemNotificationPrompt, sendPromptToAgent, waitForAgentRunStartWithTimeout, unarchiveAgentState, } from "./agent/agent-prompt.js";
-import { resolveCreateAgentTitles } from "./agent/create-agent-title.js";
+import { resolveCreateAgentTitles, resolveFirstAgentPromptTitle, } from "./agent/create-agent-title.js";
 import { respondToAgentPermission } from "./agent/permission-response.js";
 import { experimental_createMCPClient } from "ai";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
@@ -2169,6 +2169,7 @@ export class Session {
                 ...(trimmedPrompt ? { prompt: trimmedPrompt } : {}),
                 ...(attachments && attachments.length > 0 ? { attachments } : {}),
             };
+            const workspacePromptTitle = resolveFirstAgentPromptTitle(firstAgentContext);
             const createdWorktree = await this.createAgentLifecycleDispatch.createWorktreeForRequest({
                 cwd: config.cwd,
                 target: worktree,
@@ -2179,12 +2180,12 @@ export class Session {
             const createAgentConfig = createdWorktree
                 ? { ...config, cwd: createdWorktree.worktree.worktreePath }
                 : config;
-            // Ownership comes from an explicit id (worktree or request). An agent
-            // created with no explicit workspace mints a fresh one — we never resolve
-            // an existing workspace by cwd, because many workspaces may share a cwd.
-            const workspaceId = createdWorktree?.workspace.workspaceId ??
-                msg.workspaceId ??
-                (await this.createWorkspaceForDirectory(createAgentConfig.cwd)).workspaceId;
+            const workspaceId = await this.resolveOrCreateWorkspaceIdForCreateAgent({
+                createdWorktree,
+                requestedWorkspaceId: msg.workspaceId,
+                cwd: createAgentConfig.cwd,
+                initialTitle: workspacePromptTitle,
+            });
             const { snapshot, liveSnapshot } = await createAgentCommand({
                 agentManager: this.agentManager,
                 agentStorage: this.agentStorage,
@@ -2210,6 +2211,9 @@ export class Session {
                 buildSessionConfig: (sessionConfig, gitOptions, legacyWorktreeName, ctx) => this.buildAgentSessionConfig(sessionConfig, gitOptions, legacyWorktreeName, ctx),
             });
             createdAgentId = snapshot.id;
+            if (!createdWorktree && msg.workspaceId) {
+                await this.writeInitialWorkspaceTitleIfUntitled(workspaceId, workspacePromptTitle);
+            }
             await this.forwardAgentUpdate(snapshot);
             if (!createdWorktree && trimmedPrompt) {
                 await this.scheduleAutoNameLocalWorkspaceTitleForFirstAgent({
@@ -2585,26 +2589,43 @@ export class Session {
         await this.applyGeneratedWorkspaceTitle(input.workspace.workspaceId, {
             title: generatedTitle,
             branch: result.branchName,
+            promptTitle: resolveFirstAgentPromptTitle(input.firstAgentContext),
         });
         await this.notifyGitMutation(input.workspace.cwd, "rename-branch");
         await this.emitWorkspaceUpdateForCwd(input.workspace.cwd);
     }
-    // applyGeneratedWorkspaceTitle fills the generated title only while the
-    // workspace is still untitled. It re-reads the current record from the
-    // registry so concurrent upserts that happened after workspace creation are
-    // not clobbered, while still persisting branch metadata from the rename path.
+    // Generated names may replace the prompt title set at creation, but not a user
+    // rename that landed while the async generator was running.
     async applyGeneratedWorkspaceTitle(workspaceId, input) {
         const current = await this.workspaceRegistry.get(workspaceId);
         if (!current) {
             return;
         }
+        let title = current.title;
+        if (!title || (input.promptTitle && title === input.promptTitle)) {
+            title = input.title;
+        }
         await this.workspaceRegistry.upsert({
             ...current,
-            title: current.title || input.title,
+            title,
             ...(input.branch ? { branch: input.branch } : {}),
             updatedAt: new Date().toISOString(),
         });
     }
+    async writeInitialWorkspaceTitleIfUntitled(workspaceId, title) {
+        if (!title) {
+            return;
+        }
+        const current = await this.workspaceRegistry.get(workspaceId);
+        if (!current || current.title) {
+            return;
+        }
+        await this.workspaceRegistry.upsert({
+            ...current,
+            title,
+            updatedAt: new Date().toISOString(),
+        });
+    }
     // Wraps the injected workspace-name generator for a directory workspace.
     async generateWorkspaceTitleFromContext(input) {
         return this.generateWorkspaceName({
@@ -2619,8 +2640,7 @@ export class Session {
         });
     }
     // Generates a human title for a directory workspace from the firstAgentContext
-    // prompt and writes it as displayName. No branch rename — directory workspaces
-    // have no worktree git state.
+    // prompt. No branch rename — directory workspaces have no worktree git state.
     // TODO(K7): same-dir directory-workspace display disambiguation not yet implemented.
     async maybeAutoNameDirectoryWorkspaceTitle(input) {
         const generated = await this.generateWorkspaceTitleFromContext({
@@ -2633,7 +2653,10 @@ export class Session {
         }
         // K4: applyGeneratedWorkspaceTitle re-reads from the registry before writing.
         // Directory workspaces have no branch — write only the title.
-        await this.applyGeneratedWorkspaceTitle(input.workspaceId, { title });
+        await this.applyGeneratedWorkspaceTitle(input.workspaceId, {
+            title,
+            promptTitle: resolveFirstAgentPromptTitle(input.firstAgentContext),
+        });
         await this.emitWorkspaceUpdateForWorkspaceId(input.workspaceId);
     }
     async scheduleAutoNameLocalWorkspaceTitleForFirstAgent(input) {
@@ -3011,8 +3034,13 @@ export class Session {
         const prompt = await buildMetadataPrompt({
             cwd,
             workspaceGitService: this.workspaceGitService,
-            configKey: "commitMessage",
-            before: "Write a concise git commit message for the changes below.",
+            contract: "Write a concise git commit message for the changes below.",
+            styles: [
+                {
+                    configKey: "commitMessage",
+                    default: "Concise, imperative mood, no trailing period.",
+                },
+            ],
             after: [
                 "Return JSON only with a single field 'message'.",
                 "",
@@ -3079,8 +3107,13 @@ export class Session {
         const prompt = await buildMetadataPrompt({
             cwd,
             workspaceGitService: this.workspaceGitService,
-            configKey: "pullRequest",
-            before: "Write a pull request title and body for the changes below.",
+            contract: "Write a pull request title and body for the changes below.",
+            styles: [
+                {
+                    configKey: "pullRequest",
+                    default: "Clear, descriptive title; body explaining what changed and why.",
+                },
+            ],
             after: [
                 "Return JSON only with fields 'title' and 'body'.",
                 "",
@@ -5221,7 +5254,16 @@ export class Session {
         }
         return this.createWorkspaceForDirectory(normalizedCwd);
     }
-    async createWorkspaceForDirectory(cwd) {
+    async resolveOrCreateWorkspaceIdForCreateAgent(input) {
+        if (input.createdWorktree) {
+            return input.createdWorktree.workspace.workspaceId;
+        }
+        if (input.requestedWorkspaceId) {
+            return input.requestedWorkspaceId;
+        }
+        return (await this.createWorkspaceForDirectory(input.cwd, input.initialTitle)).workspaceId;
+    }
+    async createWorkspaceForDirectory(cwd, title) {
         const checkout = await this.workspaceGitService.getCheckout(cwd);
         const membership = classifyDirectoryForProjectMembership({ cwd, checkout });
         const timestamp = new Date().toISOString();
@@ -5236,6 +5278,7 @@ export class Session {
             cwd,
             kind: membership.workspaceKind,
             displayName: membership.workspaceDisplayName,
+            title: title ?? null,
             createdAt: timestamp,
             updatedAt: timestamp,
         });
@@ -5765,7 +5808,9 @@ export class Session {
             });
             return;
         }
-        const workspace = await createLocalCheckoutWorkspace({ cwd, title: request.title ?? null }, {
+        const explicitTitle = request.title?.trim() || null;
+        const promptTitle = resolveFirstAgentPromptTitle(request.firstAgentContext);
+        const workspace = await createLocalCheckoutWorkspace({ cwd, title: explicitTitle ?? promptTitle }, {
             projectRegistry: this.projectRegistry,
             workspaceRegistry: this.workspaceRegistry,
             workspaceGitService: this.workspaceGitService,

package/dist/server/server/workspace-registry.js

@@ -173,9 +173,9 @@ export function createPersistedWorkspaceRecord(input) {
         archivedAt: input.archivedAt ?? null,
     });
 }
-// The single workspace-name rule: the user-set title always wins; otherwise fall
-// back to the freshest available derived display name (a live branch snapshot when
-// the caller has one, the persisted displayName otherwise).
+// The single workspace-name rule: the title always wins; otherwise fall back to
+// the freshest available derived display name (a live branch snapshot when the
+// caller has one, the persisted displayName otherwise).
 export function resolveWorkspaceName(input) {
     return input.title ?? input.derivedDisplayName;
 }

package/dist/server/server/worktree-branch-name-generator.js

@@ -11,14 +11,30 @@ async function buildPrompt(seed, options) {
     return buildMetadataPrompt({
         cwd: options.cwd,
         workspaceGitService: options.workspaceGitService,
-        configKey: "branchName",
-        before: [
-            "Generate a git branch name for a coding agent based on the user prompt and attachments.",
-            "Title: a short human-readable sentence-case label for the task (no slug rules, max 80 characters).",
-            "Branch: concise lowercase slug using letters, numbers, hyphens, and slashes only.",
-            "No spaces, no uppercase, no leading or trailing hyphen, no consecutive hyphens.",
+        contract: [
+            "Generate a title and a git branch name for a coding agent from the user prompt and attachments.",
+            "The branch must be a valid git ref: lowercase letters, numbers, hyphens, and slashes only, with no spaces, no uppercase, no leading or trailing hyphen, and no consecutive hyphens.",
             "The branch is generated directly from the prompt — it is NEVER derived from or slugified from the title.",
         ].join("\n"),
+        styles: [
+            {
+                configKey: "title",
+                label: "Title style",
+                default: [
+                    "A terse, task-shaped label naming what the task is about (sentence case, max 80 characters).",
+                    "Aim for about 4 words. Go longer only when the task genuinely needs it; most titles must stay short.",
+                    "Do not start with a generic 'do' verb (Fix, Add, Implement, Diagnose, Update, Change, Create, Set, Make) — every task is implicitly one of these, so the verb is noise. Name the thing instead.",
+                    "Keep a verb only when it states the specific operation (Swap, Split, Extract, Rename, Merge, Inline).",
+                    'Good titles: "Swap sidebar history icon", "Composer keyboard shift", "Agent auto-titling", "Worktree selection memory", "Split browser pane".',
+                    'Bad titles: "Fix composer pushed up by keyboard in workspace", "Diagnose auto-titling still happening for agents", "Change sidebar history icon from clock to history icon".',
+                ].join("\n"),
+            },
+            {
+                configKey: "branchName",
+                label: "Branch style",
+                default: "A short, descriptive slug — a few lowercase words joined by hyphens.",
+            },
+        ],
         after: "Return JSON only with fields 'title' and 'branch'.",
         trailing: `User context:\n${seed}`,
     });

package/dist/server/utils/build-metadata-prompt.d.ts

@@ -1,11 +1,16 @@
-export type MetadataConfigKey = "branchName" | "commitMessage" | "pullRequest";
+export type MetadataConfigKey = "title" | "branchName" | "commitMessage" | "pullRequest";
 export interface RepoRootResolver {
     resolveRepoRoot: (cwd: string) => Promise<string>;
 }
+export interface MetadataStyleSection {
+    configKey: MetadataConfigKey;
+    default: string;
+    label?: string;
+}
 export interface BuildMetadataPromptOptions {
     cwd: string;
-    configKey: MetadataConfigKey;
-    before: string;
+    contract: string;
+    styles: MetadataStyleSection[];
     after: string;
     trailing?: string;
     workspaceGitService?: RepoRootResolver;

package/dist/server/utils/build-metadata-prompt.js

@@ -1,22 +1,23 @@
 import { readPaseoConfigJson } from "./paseo-config-file.js";
-import { PaseoConfigSchema } from "@getpaseo/protocol/paseo-config-schema";
-import { wrapWithUserInstructions } from "./wrap-user-instructions.js";
+import { PaseoConfigSchema, } from "@getpaseo/protocol/paseo-config-schema";
 export async function buildMetadataPrompt(options) {
-    const instructions = await readProjectMetadataInstructions(options);
-    const head = isNonEmptyString(instructions)
-        ? wrapWithUserInstructions(options.before, instructions, options.after)
-        : `${options.before}\n${options.after}`;
+    const overrides = await readProjectMetadataOverrides(options);
+    const styleBlocks = options.styles.map((section) => renderStyleSection(section, overrides?.[section.configKey]?.instructions));
+    const head = [options.contract, ...styleBlocks, options.after].join("\n\n");
     return options.trailing ? `${head}\n\n${options.trailing}` : head;
 }
-async function readProjectMetadataInstructions(options) {
+function renderStyleSection(section, override) {
+    const body = isNonEmptyString(override) ? override.trim() : section.default;
+    return section.label ? `${section.label}:\n${body}` : body;
+}
+async function readProjectMetadataOverrides(options) {
     if (!options.workspaceGitService) {
         return undefined;
     }
     try {
         const repoRoot = await options.workspaceGitService.resolveRepoRoot(options.cwd);
         const json = readPaseoConfigJson(repoRoot);
-        const config = PaseoConfigSchema.parse(json);
-        return config.metadataGeneration?.[options.configKey]?.instructions;
+        return PaseoConfigSchema.parse(json).metadataGeneration;
     }
     catch {
         return undefined;

package/package.json

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

package/dist/server/utils/wrap-user-instructions.d.ts

@@ -1,2 +0,0 @@
-export declare function wrapWithUserInstructions(beforeBlock: string, instructions: string, afterBlock: string): string;
-//# sourceMappingURL=wrap-user-instructions.d.ts.map

package/dist/server/utils/wrap-user-instructions.js

@@ -1,13 +0,0 @@
-const USER_INSTRUCTIONS_NOTICE = "The instructions below are provided by the project owner and override the guidelines above where they conflict.";
-export function wrapWithUserInstructions(beforeBlock, instructions, afterBlock) {
-    return `${beforeBlock}
-
-<user-instructions>
-${USER_INSTRUCTIONS_NOTICE}
-
-${instructions}
-</user-instructions>
-
-${afterBlock}`;
-}
-//# sourceMappingURL=wrap-user-instructions.js.map