@promptbook/cli 0.112.0-126 → 0.112.0-127

package/apps/agents-server/src/utils/transpilers/resolveTranspiledTeamExport.ts

@@ -1,4 +1,5 @@
 import { createAgentModelRequirements, parseAgentSource } from '@promptbook-local/core';
+import { spaceTrim } from 'spacetrim';
 import type { AgentReferenceResolver } from '../../../../../src/book-2.0/agent-source/AgentReferenceResolver';
 import { resolvePseudoAgentKindFromUrl } from '../../../../../src/book-2.0/agent-source/pseudoAgentReferences';
 import type { string_book } from '../../../../../src/book-2.0/agent-source/string_book';
@@ -140,15 +141,9 @@ async function createTranspiledTeamAgentFromSource(options: {
     readonly agentReferenceResolver: AgentReferenceResolver;
     readonly isRootAgent: boolean;
 }): Promise<TranspiledTeamAgent> {
-    const modelRequirements = await createAgentModelRequirements(
-        options.agentSource,
-        undefined,
-        undefined,
-        undefined,
-        {
-            agentReferenceResolver: options.agentReferenceResolver,
-        },
-    );
+    const modelRequirements = await createAgentModelRequirements(options.agentSource, undefined, undefined, undefined, {
+        agentReferenceResolver: options.agentReferenceResolver,
+    });
     const parsedAgentSource = parseAgentSource(options.agentSource);
     const agentName = parsedAgentSource.agentName || options.agentUrl;
 
@@ -174,7 +169,12 @@ function createPseudoTranspiledTeamAgent(teammate: TranspiledTeamTeammate): Tran
         pseudoAgentKind === 'USER'
             ? 'This pseudo-agent represents the human user. Ask for exactly one reply from the user.'
             : 'This pseudo-agent represents silence and intentionally does not answer.';
-    const agentSource = `${teammate.label}\n\nNOTE Built-in ${pseudoAgentKind || 'pseudo'} TEAM pseudo-agent.\nCLOSED`;
+    const agentSource = spaceTrim(`
+        ${teammate.label}
+
+        NOTE Built-in ${pseudoAgentKind || 'pseudo'} TEAM pseudo-agent.
+        CLOSED
+    `);
 
     return {
         url: teammate.url,

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

@@ -2,7 +2,7 @@ import type { ChatMessage, ToolCall } from '@promptbook-local/types';
 import { ASSISTANT_PREPARATION_TOOL_CALL_NAME } from '../../../../../src/types/ToolCall';
 
 /**
- * Prefix used by automatic durable chat progress items.
+ * Prefix used by automatic durable chat progress items so we can recognize and refresh them later.
  *
  * @private internal helper for Agents Server durable chat progress
  */
@@ -16,14 +16,50 @@ const AUTOMATIC_PROGRESS_ITEM_ID_PREFIX = 'user-chat-job-progress-';
 const AUTOMATIC_PROGRESS_TITLE = 'Agent Progress';
 
 /**
- * Tool names that are already represented by the progress card itself.
+ * Tool names that are never surfaced in the automatic progress card.
+ *
+ * `agent_progress` is the model's own progress channel; we never want to advertise this
+ * internal tool to the user as if it were doing visible work.
  *
  * @private internal helper for Agents Server durable chat progress
  */
 const HIDDEN_PROGRESS_TOOL_NAMES = new Set(['agent_progress']);
 
 /**
- * Options for building an automatic running progress card.
+ * Maximum number of characters surfaced from a tool log message to keep progress copy compact.
+ *
+ * @private internal helper for Agents Server durable chat progress
+ */
+const MAX_TOOL_LOG_PREVIEW_LENGTH = 140;
+
+/**
+ * Known technical tool names mapped to a user-friendly action verb phrase.
+ *
+ * Used so users see "Searching the web" instead of "Web search" or "search_web" in
+ * the progress card. Unknown tools fall back to a sentence-cased version of their raw name.
+ *
+ * @private internal helper for Agents Server durable chat progress
+ */
+const FRIENDLY_TOOL_NAME_OVERRIDES: ReadonlyMap<string, string> = new Map([
+    [ASSISTANT_PREPARATION_TOOL_CALL_NAME, 'Preparing the agent'],
+    ['web_search', 'Searching the web'],
+    ['search_web', 'Searching the web'],
+    ['search_engine_search', 'Searching the web'],
+    ['browser', 'Browsing the web'],
+    ['browser_open_url', 'Opening a web page'],
+    ['browser_read', 'Reading a web page'],
+    ['get_url_content', 'Reading a web page'],
+    ['read_url', 'Reading a web page'],
+    ['scrape', 'Reading a web page'],
+    ['file_read', 'Reading a file'],
+    ['project_read_file', 'Reading a project file'],
+    ['file_write', 'Writing a file'],
+    ['email_send', 'Sending an email'],
+    ['send_email', 'Sending an email'],
+]);
+
+/**
+ * Options for building an automatic running progress card snapshot.
  *
  * @private internal helper for Agents Server durable chat progress
  */
@@ -35,9 +71,9 @@ type CreateRunningUserChatProgressCardOptions = {
 };
 
 /**
- * Creates the initial real progress payload shown before an agent runner starts.
+ * Creates the initial real-progress payload shown before the agent starts working.
  *
- * @param updatedAt - Timestamp used for the progress-card update marker.
+ * @param updatedAt Timestamp used for the progress-card update marker.
  * @returns Structured progress card for a queued assistant placeholder.
  *
  * @private internal helper for Agents Server durable chat progress
@@ -47,17 +83,17 @@ export function createQueuedUserChatProgressCard(
 ): NonNullable<ChatMessage['progressCard']> {
     return {
         title: AUTOMATIC_PROGRESS_TITLE,
-        now: 'Your message is queued for the agent runner.',
-        next: 'The runner will prepare the agent context and start generating the response.',
+        now: 'Your message is in the queue.',
+        next: 'The agent will pick it up and start working on your reply.',
         items: [
             {
                 id: `${AUTOMATIC_PROGRESS_ITEM_ID_PREFIX}queued`,
-                text: 'Request added to the chat queue',
+                text: 'Message added to the chat queue',
                 status: 'completed',
             },
             {
                 id: `${AUTOMATIC_PROGRESS_ITEM_ID_PREFIX}waiting-for-runner`,
-                text: 'Waiting for an available agent runner',
+                text: 'Waiting for the agent to start',
                 status: 'pending',
             },
         ],
@@ -69,10 +105,10 @@ export function createQueuedUserChatProgressCard(
 /**
  * Creates or refreshes the automatic progress card for a running durable chat job.
  *
- * A model-authored `agent_progress` card is preserved once it takes over, so the
- * durable runner does not overwrite more specific progress supplied by the agent.
+ * A model-authored `agent_progress` card always wins: if one is already present,
+ * the durable runner returns it unchanged so the model can drive its own narrative.
  *
- * @param options - Current message state and streamed runtime details.
+ * @param options Current message state and the latest streamed runtime details.
  * @returns Progress card that should be stored on the assistant message.
  *
  * @private internal helper for Agents Server durable chat progress
@@ -84,8 +120,10 @@ export function createRunningUserChatProgressCard(
         return options.currentProgressCard;
     }
 
-    const visibleToolCalls = (options.toolCalls || []).filter((toolCall) => !HIDDEN_PROGRESS_TOOL_NAMES.has(toolCall.name));
-    const hasVisibleToolCalls = visibleToolCalls.length > 0;
+    const visibleToolCalls = (options.toolCalls || []).filter(
+        (toolCall) => !HIDDEN_PROGRESS_TOOL_NAMES.has(toolCall.name),
+    );
+    const activeToolCalls = visibleToolCalls.filter((toolCall) => !isToolCallComplete(toolCall));
     const hasStartedWriting = options.content.trim().length > 0;
 
     return {
@@ -93,24 +131,26 @@ export function createRunningUserChatProgressCard(
         now: resolveRunningProgressNowText({
             hasStartedWriting,
             visibleToolCalls,
+            activeToolCalls,
+        }),
+        next: resolveRunningProgressNextText({
+            hasStartedWriting,
+            activeToolCalls,
         }),
-        next: hasVisibleToolCalls
-            ? 'Tool results will be incorporated into the final response.'
-            : 'The final answer will replace this progress view when generation finishes.',
         items: [
             {
                 id: `${AUTOMATIC_PROGRESS_ITEM_ID_PREFIX}queued`,
-                text: 'Request added to the chat queue',
+                text: 'Message added to the chat queue',
                 status: 'completed',
             },
             {
                 id: `${AUTOMATIC_PROGRESS_ITEM_ID_PREFIX}runtime-prepared`,
-                text: 'Agent context and runtime tools prepared',
+                text: 'Agent is ready',
                 status: 'completed',
             },
             {
                 id: `${AUTOMATIC_PROGRESS_ITEM_ID_PREFIX}generating-response`,
-                text: hasStartedWriting ? 'Response text has started streaming' : 'Generating the assistant response',
+                text: hasStartedWriting ? 'Writing the answer for you' : 'Thinking through your request',
                 status: hasStartedWriting ? 'completed' : 'pending',
             },
             ...visibleToolCalls.map(createToolCallProgressItem),
@@ -121,9 +161,9 @@ export function createRunningUserChatProgressCard(
 }
 
 /**
- * Returns true when the existing progress card should be treated as model-authored.
+ * Returns true when an existing progress card was authored by the model and should not be overwritten.
  *
- * @param progressCard - Existing progress-card payload on the assistant message.
+ * @param progressCard Existing progress-card payload on the assistant message.
  * @returns Whether automatic runner progress should leave the card untouched.
  *
  * @private internal helper for Agents Server durable chat progress
@@ -145,36 +185,75 @@ function shouldPreserveModelProgressCard(
 /**
  * Resolves the current-work copy for a running progress card.
  *
- * @param options - Running output and tool-call state.
- * @returns Concise progress-card text.
+ * Prefers a friendly preview of the latest tool log so the user can see what is
+ * actually happening, then falls back to higher-level phase descriptions.
+ *
+ * @param options Running output and tool-call snapshot summary.
+ * @returns Concise user-facing progress-card "now" text.
  *
  * @private internal helper for Agents Server durable chat progress
  */
 function resolveRunningProgressNowText(options: {
     readonly hasStartedWriting: boolean;
     readonly visibleToolCalls: ReadonlyArray<ToolCall>;
+    readonly activeToolCalls: ReadonlyArray<ToolCall>;
 }): string {
+    const latestActiveLogText = resolveLatestToolLogPhrase(options.activeToolCalls);
+    if (latestActiveLogText) {
+        return latestActiveLogText;
+    }
+
+    if (options.activeToolCalls.length > 0) {
+        return `${formatToolCallActionList(options.activeToolCalls)}.`;
+    }
+
+    if (options.hasStartedWriting) {
+        return 'Writing the answer for you.';
+    }
+
     if (options.visibleToolCalls.length > 0) {
-        return `Using ${formatToolCallList(options.visibleToolCalls)}.`;
+        return 'Reviewing what the tools returned.';
     }
 
+    return 'Thinking through your request.';
+}
+
+/**
+ * Resolves the upcoming-work copy for a running progress card.
+ *
+ * @param options Running output and tool-call snapshot summary.
+ * @returns Concise user-facing progress-card "next" text.
+ *
+ * @private internal helper for Agents Server durable chat progress
+ */
+function resolveRunningProgressNextText(options: {
+    readonly hasStartedWriting: boolean;
+    readonly activeToolCalls: ReadonlyArray<ToolCall>;
+}): string {
     if (options.hasStartedWriting) {
-        return 'The agent has started writing the response.';
+        return 'Finishing up the answer.';
     }
 
-    return 'The agent runtime is prepared and the model is generating the response.';
+    if (options.activeToolCalls.length > 0) {
+        return 'The results will be turned into your answer.';
+    }
+
+    return 'The answer will appear here once it is ready.';
 }
 
 /**
  * Creates one checklist item from an observed tool-call snapshot.
  *
- * @param toolCall - Tool call observed while the model is running.
- * @param index - Position of the tool call in the current snapshot.
- * @returns Progress item for the tool action.
+ * @param toolCall Tool call observed while the model is running.
+ * @param index Position of the tool call in the current snapshot.
+ * @returns Progress item describing the tool action.
  *
  * @private internal helper for Agents Server durable chat progress
  */
-function createToolCallProgressItem(toolCall: ToolCall, index: number): NonNullable<ChatMessage['progressCard']>['items'][number] {
+function createToolCallProgressItem(
+    toolCall: ToolCall,
+    index: number,
+): NonNullable<ChatMessage['progressCard']>['items'][number] {
     return {
         id: `${AUTOMATIC_PROGRESS_ITEM_ID_PREFIX}tool-${resolveToolCallProgressId(toolCall, index)}`,
         text: resolveToolCallProgressText(toolCall),
@@ -183,10 +262,10 @@ function createToolCallProgressItem(toolCall: ToolCall, index: number): NonNulla
 }
 
 /**
- * Creates a stable progress item id from one tool-call snapshot.
+ * Creates a stable progress item id from one tool-call snapshot so partial updates re-use the same row.
  *
- * @param toolCall - Tool call observed while the model is running.
- * @param index - Position of the tool call in the current snapshot.
+ * @param toolCall Tool call observed while the model is running.
+ * @param index Position of the tool call in the current snapshot.
  * @returns Stable id suffix for the rendered progress item.
  *
  * @private internal helper for Agents Server durable chat progress
@@ -203,75 +282,131 @@ function resolveToolCallProgressId(toolCall: ToolCall, index: number): string {
 /**
  * Resolves user-facing progress text for one tool-call snapshot.
  *
- * @param toolCall - Tool call observed while the model is running.
- * @returns Concise description of the action or result.
+ * @param toolCall Tool call observed while the model is running.
+ * @returns Concise description of the tool action or its result.
  *
  * @private internal helper for Agents Server durable chat progress
  */
 function resolveToolCallProgressText(toolCall: ToolCall): string {
-    const toolTitle = formatToolName(toolCall.name);
-    const latestLog = [...(toolCall.logs || [])].reverse().find((log) => log.title || log.message);
-
-    if (toolCall.name === ASSISTANT_PREPARATION_TOOL_CALL_NAME) {
-        return 'Preparing assistant runtime';
-    }
+    const toolAction = resolveFriendlyToolAction(toolCall.name);
 
     if (Array.isArray(toolCall.errors) && toolCall.errors.length > 0) {
-        return `${toolTitle} reported an error`;
+        return `${toolAction} ran into a problem`;
     }
 
+    const latestLogText = resolveToolCallLatestLogText(toolCall);
     if (isToolCallComplete(toolCall)) {
-        return `${toolTitle} completed`;
+        return latestLogText ? `${toolAction} – ${latestLogText}` : `${toolAction} done`;
     }
 
-    if (latestLog) {
-        const logText = latestLog.title || latestLog.message;
-        return `${toolTitle}: ${logText}`;
+    if (latestLogText) {
+        return `${toolAction}: ${latestLogText}`;
     }
 
-    return `${toolTitle} is running`;
+    return `${toolAction}…`;
 }
 
 /**
- * Formats a short comma-separated list of active tools.
+ * Returns a friendly phrase for the latest log line observed across the given tool calls.
  *
- * @param toolCalls - Visible tool calls in the current stream snapshot.
- * @returns Human-readable tool list.
+ * @param toolCalls Tool calls to inspect.
+ * @returns Compact phrase suitable for the progress-card "now" field, or null when no log is informative.
  *
  * @private internal helper for Agents Server durable chat progress
  */
-function formatToolCallList(toolCalls: ReadonlyArray<ToolCall>): string {
-    const uniqueToolNames = [...new Set(toolCalls.map((toolCall) => formatToolName(toolCall.name)))];
+function resolveLatestToolLogPhrase(toolCalls: ReadonlyArray<ToolCall>): string | null {
+    for (let index = toolCalls.length - 1; index >= 0; index--) {
+        const toolCall = toolCalls[index]!;
+        const latestLogText = resolveToolCallLatestLogText(toolCall);
+        if (!latestLogText) {
+            continue;
+        }
 
-    if (uniqueToolNames.length === 1) {
-        return uniqueToolNames[0]!;
+        return `${resolveFriendlyToolAction(toolCall.name)}: ${latestLogText}`;
     }
 
-    const finalToolName = uniqueToolNames[uniqueToolNames.length - 1]!;
-    return `${uniqueToolNames.slice(0, -1).join(', ')} and ${finalToolName}`;
+    return null;
+}
+
+/**
+ * Returns the most recent informative log line for one tool call, truncated for compact display.
+ *
+ * @param toolCall Tool call to inspect.
+ * @returns Compact log preview or null when no informative log was observed.
+ *
+ * @private internal helper for Agents Server durable chat progress
+ */
+function resolveToolCallLatestLogText(toolCall: ToolCall): string | null {
+    if (!toolCall.logs || toolCall.logs.length === 0) {
+        return null;
+    }
+
+    for (let index = toolCall.logs.length - 1; index >= 0; index--) {
+        const logEntry = toolCall.logs[index];
+        const logText = logEntry?.title?.trim() || logEntry?.message?.trim();
+        if (!logText) {
+            continue;
+        }
+
+        if (logText.length <= MAX_TOOL_LOG_PREVIEW_LENGTH) {
+            return logText;
+        }
+
+        return `${logText.slice(0, MAX_TOOL_LOG_PREVIEW_LENGTH - 1).trimEnd()}…`;
+    }
+
+    return null;
+}
+
+/**
+ * Formats a short comma-separated description of active tool actions.
+ *
+ * @param toolCalls Visible tool calls that are still in progress.
+ * @returns Human-readable tool action list.
+ *
+ * @private internal helper for Agents Server durable chat progress
+ */
+function formatToolCallActionList(toolCalls: ReadonlyArray<ToolCall>): string {
+    const uniqueToolActions = [...new Set(toolCalls.map((toolCall) => resolveFriendlyToolAction(toolCall.name)))];
+
+    if (uniqueToolActions.length === 1) {
+        return uniqueToolActions[0]!;
+    }
+
+    const finalToolAction = uniqueToolActions[uniqueToolActions.length - 1]!;
+    return `${uniqueToolActions.slice(0, -1).join(', ')} and ${finalToolAction.toLowerCase()}`;
 }
 
 /**
  * Converts one technical tool name into compact user-facing copy.
  *
- * @param toolName - Tool function name.
- * @returns Human-readable tool name.
+ * Falls back to a sentence-cased version of the raw name when no friendly mapping is known.
+ *
+ * @param toolName Tool function name reported by the model.
+ * @returns Human-readable action phrase such as "Searching the web".
  *
  * @private internal helper for Agents Server durable chat progress
  */
-function formatToolName(toolName: string): string {
-    return toolName
+function resolveFriendlyToolAction(toolName: string): string {
+    const overriddenAction = FRIENDLY_TOOL_NAME_OVERRIDES.get(toolName);
+    if (overriddenAction) {
+        return overriddenAction;
+    }
+
+    const sentenceCasedName = toolName
         .replace(/[_-]+/g, ' ')
         .replace(/\s+/g, ' ')
         .trim()
         .replace(/^\w/, (character) => character.toUpperCase());
+
+    return sentenceCasedName.length > 0 ? sentenceCasedName : 'Running a tool';
 }
 
 /**
  * Infers whether a tool-call snapshot has reached a terminal successful state.
  *
- * @param toolCall - Tool call observed while the model is running.
- * @returns Whether the tool call has a completed result.
+ * @param toolCall Tool call observed while the model is running.
+ * @returns Whether the tool call has a completed result and should be rendered as such.
  *
  * @private internal helper for Agents Server durable chat progress
  */

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

@@ -22,6 +22,7 @@ export const VPS_ENVIRONMENT_VARIABLE_KEYS = [
     'SERVERS',
     'NEXT_PUBLIC_SITE_URL',
     'ADMIN_PASSWORD',
+    'SESSION_SECRET',
     'OPENAI_API_KEY',
     'PTBK_HARNESS',
     'PTBK_MODEL',

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

@@ -5,10 +5,26 @@ import { dirname, resolve } from 'path';
 import { promisify } from 'util';
 import { NotAllowed } from '../../../../src/errors/NotAllowed';
 import { spaceTrim } from 'spacetrim';
-import { createVpsInstallerCommandEnvironment, resolveVpsEnvironmentFilePath, resolveVpsInstallerScriptPath } from './vpsConfiguration';
+import {
+    createVpsInstallerCommandEnvironment,
+    resolveVpsEnvironmentFilePath,
+    resolveVpsInstallerScriptPath,
+} from './vpsConfiguration';
 
 const execFileAsync = promisify(execFile);
 
+/**
+ * Fallback error used when a running self-update process disappears without writing a terminal status.
+ */
+const VPS_SELF_UPDATE_STALE_ERROR_MESSAGE =
+    'The previous background update process stopped unexpectedly before writing its final status.';
+
+/**
+ * Success step shown when the server proves a stale-looking job completed across a process restart.
+ */
+const VPS_SELF_UPDATE_RESTART_SUCCESS_STEP =
+    'Standalone VPS self-update finished successfully after restarting the server.';
+
 /**
  * Supported standalone VPS update environments.
  */
@@ -166,6 +182,20 @@ export type VpsSelfUpdateOverview = {
     readonly job: VpsSelfUpdateJobSnapshot;
 };
 
+/**
+ * Repository state used to resolve a persisted self-update job for the browser overview.
+ */
+export type VpsSelfUpdateJobOverviewContext = {
+    /**
+     * Environment currently configured in the running Agents Server.
+     */
+    readonly currentEnvironment: VpsSelfUpdateEnvironmentOption;
+    /**
+     * Current local repository commit observed by the running server.
+     */
+    readonly currentCommitSha: string | null;
+};
+
 /**
  * Starts one detached VPS self-update run for the selected environment.
  *
@@ -306,6 +336,10 @@ export async function readVpsSelfUpdateOverview(): Promise<VpsSelfUpdateOverview
         runGitInRepository(repositoryDirectory, ['log', '-1', '--format=%s']),
         readRemoteCommitSha(repositoryDirectory, currentEnvironment.branch),
     ]);
+    const resolvedJob = resolveVpsSelfUpdateJobForOverview(job, {
+        currentEnvironment,
+        currentCommitSha,
+    });
 
     return {
         isAvailable: Boolean(currentCommitSha),
@@ -318,8 +352,48 @@ export async function readVpsSelfUpdateOverview(): Promise<VpsSelfUpdateOverview
         currentCommitMessage,
         latestRemoteCommitSha,
         latestRemoteCommitShortSha: abbreviateCommitSha(latestRemoteCommitSha),
-        isUpdateAvailable: Boolean(currentCommitSha && latestRemoteCommitSha && currentCommitSha !== latestRemoteCommitSha),
-        job,
+        isUpdateAvailable: Boolean(
+            currentCommitSha && latestRemoteCommitSha && currentCommitSha !== latestRemoteCommitSha,
+        ),
+        job: resolvedJob,
+    };
+}
+
+/**
+ * Converts the persisted shell status into the status that should be shown in the admin overview.
+ *
+ * A successful self-update may restart the old Agents Server process before the browser sees the final
+ * `STATUS=succeeded` write. In that case the stale PID alone is not enough to call the update failed:
+ * if the running server is already on the recorded target branch and target commit, the update succeeded.
+ *
+ * @param job - Persisted self-update job snapshot.
+ * @param context - Current repository state observed by the running server.
+ * @returns Job snapshot resolved for browser display.
+ */
+export function resolveVpsSelfUpdateJobForOverview(
+    job: VpsSelfUpdateJobSnapshot,
+    context: VpsSelfUpdateJobOverviewContext,
+): VpsSelfUpdateJobSnapshot {
+    const isRestartedSuccessfulUpdate =
+        job.status === 'failed' &&
+        job.isStale &&
+        (!job.errorMessage || job.errorMessage === VPS_SELF_UPDATE_STALE_ERROR_MESSAGE) &&
+        job.targetBranch === context.currentEnvironment.branch &&
+        job.targetCommitSha !== null &&
+        context.currentCommitSha !== null &&
+        job.targetCommitSha === context.currentCommitSha;
+
+    if (!isRestartedSuccessfulUpdate) {
+        return job;
+    }
+
+    return {
+        ...job,
+        status: 'succeeded',
+        currentStep: VPS_SELF_UPDATE_RESTART_SUCCESS_STEP,
+        currentCommitSha: context.currentCommitSha,
+        errorMessage: null,
+        isStale: false,
     };
 }
 
@@ -410,10 +484,7 @@ async function readPersistedVpsSelfUpdateJob(): Promise<VpsSelfUpdateJobSnapshot
         currentStep,
         currentCommitSha: statusEntries.get('CURRENT_COMMIT') || null,
         targetCommitSha: statusEntries.get('TARGET_COMMIT') || null,
-        errorMessage:
-            isStale && !errorMessage
-                ? 'The previous background update process stopped unexpectedly before writing its final status.'
-                : errorMessage,
+        errorMessage: isStale && !errorMessage ? VPS_SELF_UPDATE_STALE_ERROR_MESSAGE : errorMessage,
         startedAt: statusEntries.get('STARTED_AT') || null,
         finishedAt: statusEntries.get('FINISHED_AT') || null,
         isStale,
@@ -513,7 +584,9 @@ async function readConfiguredVpsEnvironmentValue(key: string): Promise<string |
  */
 async function resolveManagedPromptbookRepositoryDirectory(): Promise<string | null> {
     const configuredDirectory =
-        (await readConfiguredVpsEnvironmentValue('PTBK_REPOSITORY_DIR')) || process.env.PTBK_REPOSITORY_DIR?.trim() || '';
+        (await readConfiguredVpsEnvironmentValue('PTBK_REPOSITORY_DIR')) ||
+        process.env.PTBK_REPOSITORY_DIR?.trim() ||
+        '';
 
     if (configuredDirectory) {
         return resolve(configuredDirectory);