@promptbook/cli 0.112.0 → 0.113.0-0

package/apps/agents-server/src/utils/localChatRunner/LocalUserChatJobMetadata.ts

@@ -23,10 +23,11 @@ export function createLocalUserChatJobMetadata(options: {
     agentDirectoryName: string;
     threadId: string;
     threadCreatedAt: string;
+    jobId: string;
     queuedAt: string;
     expectedMessagesBeforeAnswer: number;
 }): LocalUserChatJobMetadata {
-    const fileName = createLocalChatMessageFileName(options.threadId, options.threadCreatedAt);
+    const fileName = createLocalChatMessageFileName(options.threadId, options.threadCreatedAt, options.jobId);
 
     return {
         version: 1,
@@ -102,15 +103,24 @@ export function withoutLocalUserChatJobMetadata(parameters: UserChatJobParameter
 /**
  * Creates the filename used by one local message-thread book.
  */
-export function createLocalChatMessageFileName(threadId: string, threadCreatedAt: string): string {
+export function createLocalChatMessageFileName(threadId: string, threadCreatedAt: string, jobId?: string): string {
     const createdOnDate = resolveLocalChatThreadCreatedOnDate(threadCreatedAt);
-    const normalizedThreadId = threadId.trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    const normalizedThreadId = threadId
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    const normalizedJobId = jobId
+        ?.trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
 
     if (normalizedThreadId.length > 0) {
-        return `${createdOnDate}-${normalizedThreadId}.book`;
+        return `${createdOnDate}-${normalizedThreadId}${normalizedJobId ? `-${normalizedJobId}` : ''}.book`;
     }
 
-    return `${createdOnDate}-${Buffer.from(threadId, 'utf8').toString('hex') || 'thread'}.book`;
+    return `${createdOnDate}-${Buffer.from(threadId, 'utf8').toString('hex') || 'thread'}${
+        normalizedJobId ? `-${normalizedJobId}` : ''
+    }.book`;
 }
 
 /**

package/apps/agents-server/src/utils/localChatRunner/processLocalUserChatJob.ts

@@ -13,7 +13,7 @@ import { createUserChatRunnerProgressCard } from '../userChat/createUserChatRunn
 import { updateUserChatAssistantMessage } from '../userChat/updateUserChatAssistantMessage';
 import type { UserChatJobRecord } from '../userChat/UserChatJobRecord';
 import type { UserChatJobRow } from '../userChat/UserChatJobRow';
-import { resolvePromptThreadBeforeUserMessage } from '../userChat/userChatMessageLifecycle';
+import { createUserChatRunnerThreadMessages } from '../userChat/userChatMessageLifecycle';
 import {
     createLocalUserChatJobMetadata,
     getLocalUserChatJobMetadata,
@@ -85,9 +85,11 @@ export async function processLocalUserChatJob(job: UserChatJobRecord): Promise<P
 /**
  * Processes the next local user chat job waiting for worker attention.
  */
-export async function processNextLocalUserChatJob(options: {
-    preferredJobId?: string;
-} = {}): Promise<ProcessLocalUserChatJobResult | null> {
+export async function processNextLocalUserChatJob(
+    options: {
+        preferredJobId?: string;
+    } = {},
+): Promise<ProcessLocalUserChatJobResult | null> {
     if (options.preferredJobId) {
         const claimedPreferredJob = await claimNextQueuedUserChatJob({ preferredJobId: options.preferredJobId });
         if (claimedPreferredJob) {
@@ -142,27 +144,11 @@ async function enqueueLocalUserChatJob(job: UserChatJobRecord): Promise<ProcessL
         throw new Error(`User message "${job.userMessageId}" was not found in chat "${job.chatId}".`);
     }
 
-    const previousThreadMessages = resolvePromptThreadBeforeUserMessage(chat.messages, job.userMessageId);
-    if (previousThreadMessages.some((message) => message.sender === 'AGENT' && message.isComplete === false)) {
-        return { didMutate: false, outcome: 'waiting' };
-    }
-
-    const agentInitialMessage = previousThreadMessages.length === 0
-        ? parseAgentSource(agentSourceSnapshot.agentSource).initialMessage
-        : null;
-    const initialAgentThreadMessages = agentInitialMessage
-        ? [{ sender: 'AGENT' as const, content: agentInitialMessage }]
-        : [];
-
-    const threadMessages = [
-        ...initialAgentThreadMessages,
-        ...[...previousThreadMessages, userMessage]
-            .filter((message) => message.isComplete !== false)
-            .filter((message) => message.sender === 'USER' || message.sender === 'AGENT'),
-    ].map((message) => ({
-        sender: String(message.sender),
-        content: message.content,
-    }));
+    const threadMessages = createUserChatRunnerThreadMessages({
+        messages: chat.messages,
+        userMessageId: job.userMessageId,
+        resolveInitialAgentMessage: () => parseAgentSource(agentSourceSnapshot.agentSource).initialMessage,
+    });
 
     const agentFolder = await ensureLocalAgentFolder(agentSourceSnapshot);
     const queuedAt = new Date().toISOString();
@@ -170,6 +156,7 @@ async function enqueueLocalUserChatJob(job: UserChatJobRecord): Promise<ProcessL
         agentDirectoryName: agentFolder.directoryName,
         threadId: chat.id,
         threadCreatedAt: chat.createdAt,
+        jobId: job.id,
         queuedAt,
         expectedMessagesBeforeAnswer: threadMessages.length,
     });
@@ -326,7 +313,11 @@ async function handleLocalUserChatJobProcessingError(
     const metadata = getLocalUserChatJobMetadata(job);
     const failureReason = error instanceof Error ? error.message : 'Local agent runner synchronization failed.';
 
-    if (job.status === 'QUEUED' || (job.status === 'RUNNING' && !metadata) || (metadata && isLocalUserChatJobTimedOut(metadata))) {
+    if (
+        job.status === 'QUEUED' ||
+        (job.status === 'RUNNING' && !metadata) ||
+        (metadata && isLocalUserChatJobTimedOut(metadata))
+    ) {
         await persistUserChatJobTerminalState({
             job,
             status: 'FAILED',

package/apps/agents-server/src/utils/serverLimits.ts

@@ -46,6 +46,7 @@ export type SpawnAgentLimits = {
  */
 export type LocalAgentRunnerLimits = {
     readonly maxFailedAttempts: number;
+    readonly maxParallelMessages: number;
 };
 
 /**
@@ -270,6 +271,7 @@ export async function getLocalAgentRunnerLimits(): Promise<LocalAgentRunnerLimit
     const limits = await getServerLimits();
     return {
         maxFailedAttempts: limits[SERVER_LIMIT_KEYS.LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS],
+        maxParallelMessages: limits[SERVER_LIMIT_KEYS.LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES],
     };
 }
 

package/apps/agents-server/src/utils/serverManagement/createManagedServer/seedServerCoreAgents.ts

@@ -35,7 +35,7 @@ export async function seedServerCoreAgents(
         const createdAt = new Date().toISOString();
         const { agentInsertRecord, agentHistoryInsertRecord } = createAgentPersistenceRecords(
             coreAgentBook,
-            { folderId: coreFolderId, sortOrder: index, visibility: DEFAULT_AGENT_VISIBILITY },
+            { folderId: coreFolderId, sortOrder: index },
             createdAt,
         );
 
@@ -158,5 +158,5 @@ async function insertCoreFolder(
         }),
     );
 
-    return insertResult.rows[0].id;
+    return insertResult.rows[0]!.id;
 }

package/apps/agents-server/src/utils/serverManagement/createManagedServer/seedServerDefaultAgents.ts

@@ -29,7 +29,7 @@ export async function seedServerDefaultAgents(
         const createdAt = new Date().toISOString();
         const { agentInsertRecord, agentHistoryInsertRecord } = createAgentPersistenceRecords(
             defaultAgentBook,
-            { sortOrder: index, visibility: DEFAULT_AGENT_VISIBILITY },
+            { sortOrder: index },
             createdAt,
         );
 

package/apps/agents-server/src/utils/userChat/createUserChatHarnessProgressCard.ts

@@ -4,11 +4,6 @@ import { TOOL_TITLES } from '../../../../../src/book-components/Chat/utils/getTo
 import { isVisibleChatToolCall } from '../../../../../src/book-components/Chat/utils/isVisibleChatToolCall';
 import { resolveToolCallState } from '../../../../../src/book-components/Chat/utils/resolveToolCallState';
 
-/**
- * Default title used while a running chat job reports harness action progress.
- */
-const USER_CHAT_HARNESS_PROGRESS_TITLE = 'Working on your request';
-
 /**
  * Creates a user-facing progress card from the latest visible harness/tool action.
  *
@@ -24,7 +19,6 @@ export function createUserChatHarnessProgressCard(
     }
 
     return {
-        title: USER_CHAT_HARNESS_PROGRESS_TITLE,
         now: createHarnessProgressNowText(latestVisibleToolCall),
         items: [],
         updatedAt: new Date().toISOString() as NonNullable<ChatMessage['progressCard']>['updatedAt'],

package/apps/agents-server/src/utils/userChat/createUserChatRunnerProgressCard.ts

@@ -11,11 +11,6 @@ export type UserChatRunnerKind = 'local' | 'external';
  */
 export type UserChatRunnerProgressPhase = 'queued_for_runner';
 
-/**
- * Default title used while an out-of-process runner is working on a chat answer.
- */
-const USER_CHAT_RUNNER_PROGRESS_TITLE = 'Working on your request';
-
 /**
  * User-facing labels for durable chat runners.
  */
@@ -35,7 +30,6 @@ export function createUserChatRunnerProgressCard(options: {
     readonly phase: UserChatRunnerProgressPhase;
 }): NonNullable<ChatMessage['progressCard']> {
     return {
-        title: USER_CHAT_RUNNER_PROGRESS_TITLE,
         now: createUserChatRunnerProgressNowText(options),
         items: [],
         updatedAt: new Date().toISOString() as NonNullable<ChatMessage['progressCard']>['updatedAt'],

package/apps/agents-server/src/utils/userChat/userChatMessageLifecycle.ts

@@ -4,6 +4,13 @@ import type { ChatMessage } from '../../../../../src/_packages/types.index';
  */
 export type UserChatMessageLifecycleState = NonNullable<ChatMessage['lifecycleState']>;
 
+/**
+ * Message shape written into local/external chat-runner `.book` files.
+ */
+export type UserChatRunnerThreadMessage = Pick<ChatMessage, 'content'> & {
+    sender: 'USER' | 'AGENT';
+};
+
 /**
  * Creates one persisted user-authored message for a durable chat turn.
  */
@@ -89,6 +96,36 @@ export function resolvePromptThreadBeforeUserMessage(
     return messages.slice(0, userMessageIndex);
 }
 
+/**
+ * Creates the complete chat thread mirrored to a runner before it writes the next answer.
+ */
+export function createUserChatRunnerThreadMessages(options: {
+    messages: ReadonlyArray<ChatMessage>;
+    userMessageId: string;
+    resolveInitialAgentMessage: () => string | null | undefined;
+}): Array<UserChatRunnerThreadMessage> {
+    const userMessage = options.messages.find((message) => message.id === options.userMessageId);
+    if (!userMessage) {
+        return [];
+    }
+
+    const previousThreadMessages = resolvePromptThreadBeforeUserMessage(options.messages, options.userMessageId);
+
+    return [
+        ...createInitialUserChatRunnerThreadMessages({
+            isFirstUserTurn: previousThreadMessages.length === 0,
+            resolveInitialAgentMessage: options.resolveInitialAgentMessage,
+        }),
+        ...previousThreadMessages,
+        userMessage,
+    ]
+        .filter(isUserChatRunnerThreadMessage)
+        .map((message) => ({
+            sender: message.sender,
+            content: message.content,
+        }));
+}
+
 /**
  * Maps durable job status values to message lifecycle labels rendered by the UI.
  */
@@ -107,3 +144,35 @@ export function resolveMessageLifecycleStateFromJobStatus(status: string): UserC
             return 'completed';
     }
 }
+
+/**
+ * Recreates the synthetic first agent message that the UI shows for empty durable chats.
+ */
+function createInitialUserChatRunnerThreadMessages(options: {
+    isFirstUserTurn: boolean;
+    resolveInitialAgentMessage: () => string | null | undefined;
+}): Array<UserChatRunnerThreadMessage> {
+    if (!options.isFirstUserTurn) {
+        return [];
+    }
+
+    const initialAgentMessage = options.resolveInitialAgentMessage();
+    if (!initialAgentMessage || initialAgentMessage.trim().length === 0) {
+        return [];
+    }
+
+    return [
+        {
+            sender: 'AGENT',
+            content: initialAgentMessage,
+        },
+    ];
+}
+
+/**
+ * Returns true when one persisted message should be visible to out-of-process runners.
+ */
+function isUserChatRunnerThreadMessage(message: ChatMessage): message is ChatMessage & UserChatRunnerThreadMessage {
+    const isRunnerSender = message.sender === 'USER' || message.sender === 'AGENT';
+    return message.isComplete !== false && isRunnerSender;
+}

package/apps/agents-server/src/utils/userChat/userChatProgressCard.ts

@@ -75,11 +75,6 @@ export type UserChatProgressContext = {
     readonly isAgentKitCached?: boolean;
 };
 
-/**
- * Default title used by durable chat progress cards.
- */
-const USER_CHAT_PROGRESS_TITLE = 'Working on your request';
-
 /**
  * Ordered progress item identifiers shared across all durable chat phases.
  */
@@ -165,7 +160,6 @@ export function createUserChatProgressCard(
     const { now, next } = composeUserChatProgressPhaseText(phase, context);
 
     return {
-        title: USER_CHAT_PROGRESS_TITLE,
         now,
         next,
         items: USER_CHAT_PROGRESS_ITEMS.map((item) => ({

package/apps/agents-server/src/utils/vpsSelfUpdate.ts

@@ -203,6 +203,10 @@ export type VpsSelfUpdateOverview = {
      * Author timestamp of the latest remote commit in ISO format.
      */
     readonly latestRemoteCommitDate: string | null;
+    /**
+     * Latest remote commit subject.
+     */
+    readonly latestRemoteCommitMessage: string | null;
     /**
      * Number of commits the deployed checkout is behind the latest remote commit, or `null` when unknown.
      */
@@ -456,22 +460,24 @@ export async function readVpsSelfUpdateOverview(): Promise<VpsSelfUpdateOverview
         });
     }
 
-    const [currentCommitSha, currentCommitMessage, currentCommitDate, latestRemoteCommitSha] = await Promise.all([
-        runGitInRepository(repositoryDirectory, ['rev-parse', 'HEAD']),
-        runGitInRepository(repositoryDirectory, ['log', '-1', '--format=%s']),
-        runGitInRepository(repositoryDirectory, ['log', '-1', '--format=%aI']),
-        readRemoteCommitSha(repositoryDirectory, currentEnvironment.branch, originRepositoryUrl),
+    await refreshVpsSelfUpdateRemoteBranch(repositoryDirectory, currentEnvironment.branch, originRepositoryUrl);
+
+    const [currentCommit, latestRemoteCommitSha] = await Promise.all([
+        readCommitMetadataFromRepository(repositoryDirectory, 'HEAD'),
+        readLatestRemoteBranchCommitSha(repositoryDirectory, currentEnvironment.branch, originRepositoryUrl),
     ]);
-    const latestRemoteCommitDate = latestRemoteCommitSha
-        ? await readCommitDateFromRepository(repositoryDirectory, latestRemoteCommitSha)
+    const latestRemoteCommit = latestRemoteCommitSha
+        ? await readCommitMetadataFromRepository(repositoryDirectory, latestRemoteCommitSha)
         : null;
+    const currentCommitSha = currentCommit?.commitSha ?? null;
+    const latestRemoteCommitResolvedSha = latestRemoteCommit?.commitSha ?? latestRemoteCommitSha;
     const commitsBehindCount =
-        currentCommitSha && latestRemoteCommitSha
-            ? await countCommitsBetween(repositoryDirectory, currentCommitSha, latestRemoteCommitSha)
+        currentCommitSha && latestRemoteCommitResolvedSha
+            ? await countCommitsBetween(repositoryDirectory, currentCommitSha, latestRemoteCommitResolvedSha)
             : null;
     const pendingCommits =
-        currentCommitSha && latestRemoteCommitSha
-            ? await listCommitsBetween(repositoryDirectory, currentCommitSha, latestRemoteCommitSha)
+        currentCommitSha && latestRemoteCommitResolvedSha
+            ? await listCommitsBetween(repositoryDirectory, currentCommitSha, latestRemoteCommitResolvedSha)
             : [];
     const resolvedJob = resolveVpsSelfUpdateJobForOverview(job, {
         currentEnvironment,
@@ -486,15 +492,16 @@ export async function readVpsSelfUpdateOverview(): Promise<VpsSelfUpdateOverview
         repositoryDirectory,
         currentCommitSha,
         currentCommitShortSha: abbreviateCommitSha(currentCommitSha),
-        currentCommitMessage,
-        currentCommitDate,
-        latestRemoteCommitSha,
-        latestRemoteCommitShortSha: abbreviateCommitSha(latestRemoteCommitSha),
-        latestRemoteCommitDate,
+        currentCommitMessage: currentCommit?.subject ?? null,
+        currentCommitDate: currentCommit?.authoredAt ?? null,
+        latestRemoteCommitSha: latestRemoteCommitResolvedSha,
+        latestRemoteCommitShortSha: abbreviateCommitSha(latestRemoteCommitResolvedSha),
+        latestRemoteCommitDate: latestRemoteCommit?.authoredAt ?? null,
+        latestRemoteCommitMessage: latestRemoteCommit?.subject ?? null,
         commitsBehindCount,
         pendingCommits,
         isUpdateAvailable: Boolean(
-            currentCommitSha && latestRemoteCommitSha && currentCommitSha !== latestRemoteCommitSha,
+            currentCommitSha && latestRemoteCommitResolvedSha && currentCommitSha !== latestRemoteCommitResolvedSha,
         ),
         originRepositoryUrl,
         isOriginRepositoryDefault: originRepositoryUrl === VPS_SELF_UPDATE_DEFAULT_ORIGIN_REPOSITORY_URL,
@@ -525,11 +532,34 @@ export type VpsSelfUpdatePendingCommit = {
     readonly authoredAt: string | null;
 };
 
+/**
+ * Browser-safe metadata read from one git commit object.
+ */
+type VpsSelfUpdateCommitMetadata = {
+    /**
+     * Full commit hash.
+     */
+    readonly commitSha: string;
+    /**
+     * Single-line commit subject.
+     */
+    readonly subject: string;
+    /**
+     * Author timestamp in ISO format or `null` when unknown.
+     */
+    readonly authoredAt: string | null;
+};
+
 /**
  * Hard ceiling for the pending-commits listing returned in the overview to avoid huge payloads on a long-stale server.
  */
 const VPS_SELF_UPDATE_MAX_PENDING_COMMITS = 100;
 
+/**
+ * Number of latest branch commits fetched for the update overview.
+ */
+const VPS_SELF_UPDATE_OVERVIEW_FETCH_DEPTH = VPS_SELF_UPDATE_MAX_PENDING_COMMITS + 1;
+
 /**
  * Browser-safe summary of one commit that the super admin can pick from the custom-target picker.
  */
@@ -825,6 +855,7 @@ function createUnavailableOverview(context: {
         latestRemoteCommitSha: null,
         latestRemoteCommitShortSha: null,
         latestRemoteCommitDate: null,
+        latestRemoteCommitMessage: null,
         commitsBehindCount: null,
         pendingCommits: [],
         isUpdateAvailable: false,
@@ -1171,6 +1202,59 @@ async function runGitInRepository(repositoryDirectory: string, args: ReadonlyArr
     }
 }
 
+/**
+ * Fetches the tracked remote branch into the local object database before building the browser overview.
+ *
+ * @param repositoryDirectory - Repository checkout path.
+ * @param branch - Target branch.
+ * @param originRepositoryUrl - Configured upstream repository URL.
+ */
+async function refreshVpsSelfUpdateRemoteBranch(
+    repositoryDirectory: string,
+    branch: string,
+    originRepositoryUrl: string,
+): Promise<void> {
+    if (!branch) {
+        return;
+    }
+
+    await runGitInRepository(repositoryDirectory, [
+        'fetch',
+        '--no-tags',
+        '--prune',
+        `--depth=${VPS_SELF_UPDATE_OVERVIEW_FETCH_DEPTH}`,
+        originRepositoryUrl,
+        `+refs/heads/${branch}:${createVpsSelfUpdateRemoteBranchReference(branch)}`,
+    ]);
+}
+
+/**
+ * Reads the latest tracked-branch commit from the local remote-tracking ref, falling back to `ls-remote`.
+ *
+ * @param repositoryDirectory - Repository checkout path.
+ * @param branch - Target branch.
+ * @param originRepositoryUrl - Configured upstream repository URL.
+ * @returns Remote branch commit sha or `null`.
+ */
+async function readLatestRemoteBranchCommitSha(
+    repositoryDirectory: string,
+    branch: string,
+    originRepositoryUrl: string,
+): Promise<string | null> {
+    if (!branch) {
+        return null;
+    }
+
+    const remoteBranchReference = createVpsSelfUpdateRemoteBranchReference(branch);
+    const localCommitSha = await runGitInRepository(repositoryDirectory, [
+        'rev-parse',
+        '--verify',
+        `${remoteBranchReference}^{commit}`,
+    ]);
+
+    return localCommitSha || readRemoteCommitSha(repositoryDirectory, branch, originRepositoryUrl);
+}
+
 /**
  * Reads the latest remote branch commit without mutating the local checkout.
  *
@@ -1197,17 +1281,47 @@ async function readRemoteCommitSha(
 }
 
 /**
- * Reads the author timestamp of a known commit from the local repository.
+ * Creates the local remote-tracking reference used for the update overview fetch.
+ *
+ * @param branch - Target branch.
+ * @returns Local remote-tracking reference.
+ */
+function createVpsSelfUpdateRemoteBranchReference(branch: string): string {
+    return `refs/remotes/origin/${branch}`;
+}
+
+/**
+ * Reads hash, subject and author timestamp for one known commit from the local repository.
  *
  * @param repositoryDirectory - Repository checkout path.
- * @param commitSha - Commit hash to look up.
- * @returns ISO timestamp or `null` when the commit is unknown locally.
+ * @param commitReference - Commit hash or git revision reference to look up.
+ * @returns Commit metadata or `null` when the commit cannot be resolved locally.
  */
-async function readCommitDateFromRepository(
+async function readCommitMetadataFromRepository(
     repositoryDirectory: string,
-    commitSha: string,
-): Promise<string | null> {
-    return runGitInRepository(repositoryDirectory, ['log', '-1', '--format=%aI', commitSha]);
+    commitReference: string,
+): Promise<VpsSelfUpdateCommitMetadata | null> {
+    const output = await runGitInRepository(repositoryDirectory, [
+        'log',
+        '-1',
+        `--format=%H${GIT_LOG_FIELD_SEPARATOR}%aI${GIT_LOG_FIELD_SEPARATOR}%s`,
+        commitReference,
+    ]);
+    if (!output) {
+        return null;
+    }
+
+    const fields = output.split(GIT_LOG_FIELD_SEPARATOR);
+    const commitSha = fields[0] ?? '';
+    if (!commitSha) {
+        return null;
+    }
+
+    return {
+        commitSha,
+        authoredAt: fields[1] || null,
+        subject: fields.slice(2).join(GIT_LOG_FIELD_SEPARATOR),
+    };
 }
 
 /**

package/esm/apps/agents-server/src/constants/serverLimits.d.ts

@@ -28,6 +28,12 @@ export declare const DEFAULT_SPAWN_AGENT_RATE_LIMIT_WINDOW_MS: number;
  * @private shared Agents Server constant
  */
 export declare const DEFAULT_LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS = 3;
+/**
+ * Default maximum number of local runner harness instances allowed to answer queued messages at once.
+ *
+ * @private shared Agents Server constant
+ */
+export declare const DEFAULT_LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES = 3;
 /**
  * Stable keys used by the dedicated server-limits table.
  *
@@ -42,6 +48,7 @@ export declare const SERVER_LIMIT_KEYS: {
     readonly SPAWN_AGENT_RATE_LIMIT_MAX: "SPAWN_AGENT_RATE_LIMIT_MAX";
     readonly SPAWN_AGENT_RATE_LIMIT_WINDOW_MS: "SPAWN_AGENT_RATE_LIMIT_WINDOW_MS";
     readonly LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS: "LOCAL_AGENT_RUNNER_MAX_FAILED_ATTEMPTS";
+    readonly LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES: "LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES";
 };
 /**
  * One supported dedicated server-limit key.
@@ -156,6 +163,16 @@ export declare const SERVER_LIMIT_DEFINITIONS: ({
     minimumValue: number;
     step: number;
     legacyMetadataKeys: never[];
+} | {
+    key: "LOCAL_AGENT_RUNNER_MAX_PARALLEL_MESSAGES";
+    category: "Local agent runner";
+    title: string;
+    description: string;
+    unit: "count";
+    defaultValue: number;
+    minimumValue: number;
+    step: number;
+    legacyMetadataKeys: never[];
 })[];
 /**
  * Fast lookup map used by server-limit validators and UI helpers.