@promptbook/cli 0.114.0-3 → 0.114.0-31

package/src/book-3.0/AgentPlannedMessagesSidecar.ts

@@ -0,0 +1,284 @@
+import { join } from 'path';
+import { AGENT_MESSAGES_DIRECTORY_PATH } from './agentFolderPaths';
+import { createAgentMessageSidecarBaseName } from './createAgentMessageSidecarBaseName';
+
+// Note: [💞] This file defines the shared planned-message sidecar convention rather than one standalone entity.
+
+/**
+ * Relative directory holding the planned-message sidecar of each queued message.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export const AGENT_PLANNED_MESSAGES_DIRECTORY_PATH = join(AGENT_MESSAGES_DIRECTORY_PATH, 'planned');
+
+/**
+ * Command actions an agent can request from its planned-message sidecar.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export const AGENT_PLANNED_MESSAGE_COMMAND_ACTIONS = ['set', 'update', 'cancel'] as const;
+
+/**
+ * One planned-message command action.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentPlannedMessageCommandAction = (typeof AGENT_PLANNED_MESSAGE_COMMAND_ACTIONS)[number];
+
+/**
+ * One planned message that is already waiting to wake the agent.
+ *
+ * A planned message can repeat like `setInterval`, run a bounded number of times, or wake the agent
+ * only once, so the whole schedule is what the agent compares with its goal, while `dueAt` only says
+ * when the nearest wake-up happens.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentPlannedMessageSnapshot = {
+    readonly timeoutId: string;
+    readonly dueAt: string;
+    readonly message: string | null;
+
+    /**
+     * Repeat interval in milliseconds, or `null` for a planned message that does not repeat at a fixed
+     * interval.
+     */
+    readonly intervalMs: number | null;
+
+    /**
+     * Five-field cron expression driving the repetitions, or `null` when the planned message does not
+     * follow a cron.
+     */
+    readonly cronExpression: string | null;
+
+    /**
+     * Moment before which the planned message never wakes the agent, or `null` when it has no starting
+     * date.
+     */
+    readonly startsAt: string | null;
+
+    /**
+     * Moment after which the planned message never wakes the agent again, or `null` when it has no
+     * ending date.
+     */
+    readonly endsAt: string | null;
+
+    /**
+     * Total number of wake-ups the planned message performs, or `null` when it repeats until it is
+     * cancelled.
+     */
+    readonly maxRunCount: number | null;
+
+    /**
+     * Number of times the planned message already woke the agent.
+     */
+    readonly runCount: number;
+};
+
+/**
+ * One command written by the coding harness into its planned-message sidecar.
+ *
+ * The payload stays untyped on purpose: it is untrusted harness output and is validated by the very
+ * same shared planned-message actions that back the model tools and the internal runtime API.
+ *
+ * For a `set` command, `milliseconds` is the repeat interval of the planned message, not a one-shot
+ * delay, and `cronExpression`, `startsAt`, `endsAt`, and `maxRunCount` bound how it repeats. An
+ * `update` command changes the very same fields of the planned message named by `timeoutId`, where a
+ * field that is left out stays as it is and an explicit `null` removes the bound.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentPlannedMessageCommand = {
+    readonly action: AgentPlannedMessageCommandAction;
+    readonly milliseconds?: unknown;
+    readonly cronExpression?: unknown;
+    readonly startsAt?: unknown;
+    readonly endsAt?: unknown;
+    readonly maxRunCount?: unknown;
+    readonly message?: unknown;
+    readonly timeoutId?: unknown;
+};
+
+/**
+ * Planned-message sidecar prepared for one queued message.
+ *
+ * `currentPlannedMessages` is written by the Agents Server and is read-only for the agent, while
+ * `commands` is the only channel through which a coding harness can plan or cancel a wake-up.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentPlannedMessagesSidecar = {
+    readonly version: 1;
+    readonly agentPermanentId: string;
+    readonly currentPlannedMessages: ReadonlyArray<AgentPlannedMessageSnapshot>;
+    readonly commands: ReadonlyArray<AgentPlannedMessageCommand>;
+};
+
+/**
+ * Creates the relative planned-message sidecar path of one queued message.
+ *
+ * @param messageFileName - File name of the queued `.book` message.
+ * @returns Relative path of the sidecar inside the agent folder.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function createAgentPlannedMessagesSidecarPath(messageFileName: string): string {
+    return join(AGENT_PLANNED_MESSAGES_DIRECTORY_PATH, `${createAgentMessageSidecarBaseName(messageFileName)}.json`);
+}
+
+/**
+ * Serializes one planned-message sidecar into its stored representation.
+ *
+ * @param sidecar - Sidecar prepared for one queued message.
+ * @returns Pretty-printed JSON the coding harness can edit by hand.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function createAgentPlannedMessagesSidecarContent(sidecar: AgentPlannedMessagesSidecar): string {
+    return `${JSON.stringify(sidecar, null, 2)}\n`;
+}
+
+/**
+ * Parses one untrusted planned-message sidecar written back by a coding harness.
+ *
+ * A malformed sidecar never fails the already answered chat, so this returns `null` instead of throwing.
+ *
+ * @param sidecarContent - Raw file content read from the agent folder.
+ * @returns Normalized sidecar, or `null` when it cannot be used.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function parseAgentPlannedMessagesSidecar(sidecarContent: string): AgentPlannedMessagesSidecar | null {
+    let parsedSidecar: unknown;
+
+    try {
+        parsedSidecar = JSON.parse(sidecarContent);
+    } catch {
+        return null;
+    }
+
+    if (!parsedSidecar || typeof parsedSidecar !== 'object' || Array.isArray(parsedSidecar)) {
+        return null;
+    }
+
+    const sidecar = parsedSidecar as Partial<AgentPlannedMessagesSidecar>;
+
+    if (sidecar.version !== 1 || typeof sidecar.agentPermanentId !== 'string') {
+        return null;
+    }
+
+    return {
+        version: 1,
+        agentPermanentId: sidecar.agentPermanentId,
+        currentPlannedMessages: normalizeAgentPlannedMessageSnapshots(sidecar.currentPlannedMessages),
+        commands: normalizeAgentPlannedMessageCommands(sidecar.commands),
+    };
+}
+
+/**
+ * Keeps only the commands whose action is understood by the planned-message actions.
+ *
+ * @param rawCommands - Untrusted `commands` value read from one sidecar.
+ * @returns Commands that can be dispatched, in their original order.
+ *
+ * @private internal utility of `parseAgentPlannedMessagesSidecar`
+ */
+function normalizeAgentPlannedMessageCommands(rawCommands: unknown): Array<AgentPlannedMessageCommand> {
+    if (!Array.isArray(rawCommands)) {
+        return [];
+    }
+
+    return rawCommands.filter(isAgentPlannedMessageCommand);
+}
+
+/**
+ * Checks whether one untrusted sidecar entry names a supported planned-message action.
+ *
+ * @param value - Untrusted command entry.
+ * @returns `true` when the entry can be dispatched.
+ *
+ * @private internal utility of `parseAgentPlannedMessagesSidecar`
+ */
+function isAgentPlannedMessageCommand(value: unknown): value is AgentPlannedMessageCommand {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+
+    const action = (value as AgentPlannedMessageCommand).action;
+
+    return (
+        typeof action === 'string' &&
+        AGENT_PLANNED_MESSAGE_COMMAND_ACTIONS.includes(action as AgentPlannedMessageCommandAction)
+    );
+}
+
+/**
+ * Keeps only the already planned messages that can be shown to the agent.
+ *
+ * @param rawSnapshots - Untrusted `currentPlannedMessages` value read from one sidecar.
+ * @returns Planned-message snapshots with the fields required for display and cancellation.
+ *
+ * @private internal utility of `parseAgentPlannedMessagesSidecar`
+ */
+function normalizeAgentPlannedMessageSnapshots(rawSnapshots: unknown): Array<AgentPlannedMessageSnapshot> {
+    if (!Array.isArray(rawSnapshots)) {
+        return [];
+    }
+
+    return rawSnapshots.filter(isAgentPlannedMessageSnapshot).map(createNormalizedAgentPlannedMessageSnapshot);
+}
+
+/**
+ * Normalizes the optional fields of one already planned message.
+ *
+ * @param snapshot - Planned-message entry with the required identity fields.
+ * @returns Snapshot with a usable schedule and message.
+ *
+ * @private internal utility of `parseAgentPlannedMessagesSidecar`
+ */
+function createNormalizedAgentPlannedMessageSnapshot(
+    snapshot: AgentPlannedMessageSnapshot,
+): AgentPlannedMessageSnapshot {
+    return {
+        timeoutId: snapshot.timeoutId,
+        dueAt: snapshot.dueAt,
+        message: typeof snapshot.message === 'string' ? snapshot.message : null,
+        intervalMs: normalizeAgentPlannedMessagePositiveCount(snapshot.intervalMs),
+        cronExpression: typeof snapshot.cronExpression === 'string' ? snapshot.cronExpression : null,
+        startsAt: typeof snapshot.startsAt === 'string' ? snapshot.startsAt : null,
+        endsAt: typeof snapshot.endsAt === 'string' ? snapshot.endsAt : null,
+        maxRunCount: normalizeAgentPlannedMessagePositiveCount(snapshot.maxRunCount),
+        runCount: normalizeAgentPlannedMessagePositiveCount(snapshot.runCount) || 0,
+    };
+}
+
+/**
+ * Normalizes one optional positive whole number of a planned-message snapshot.
+ *
+ * @param value - Untrusted interval, run count, or run-count limit.
+ * @returns Whole positive number, or `null` when the value cannot be used.
+ *
+ * @private internal utility of `parseAgentPlannedMessagesSidecar`
+ */
+function normalizeAgentPlannedMessagePositiveCount(value: unknown): number | null {
+    const numericValue = Number(value);
+
+    return Number.isFinite(numericValue) && numericValue > 0 ? Math.floor(numericValue) : null;
+}
+
+/**
+ * Checks whether one untrusted sidecar entry describes an already planned message.
+ *
+ * @param value - Untrusted planned-message entry.
+ * @returns `true` when the entry can be shown and cancelled.
+ *
+ * @private internal utility of `parseAgentPlannedMessagesSidecar`
+ */
+function isAgentPlannedMessageSnapshot(value: unknown): value is AgentPlannedMessageSnapshot {
+    return Boolean(
+        value &&
+            typeof value === 'object' &&
+            typeof (value as AgentPlannedMessageSnapshot).timeoutId === 'string' &&
+            typeof (value as AgentPlannedMessageSnapshot).dueAt === 'string',
+    );
+}

package/src/book-3.0/AgentTeamConversationWorkspace.ts

@@ -0,0 +1,170 @@
+import { join } from 'path';
+import { AGENT_FINISHED_MESSAGES_DIRECTORY_PATH, AGENT_MESSAGES_DIRECTORY_PATH } from './agentFolderPaths';
+import { createAgentMessageSidecarBaseName } from './createAgentMessageSidecarBaseName';
+
+// Note: [💞] This file defines the shared TEAM workspace convention rather than one standalone entity.
+
+/**
+ * Relative directory for an active TEAM conversation workspace.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export const AGENT_TEAM_CONVERSATIONS_DIRECTORY_PATH = join(AGENT_MESSAGES_DIRECTORY_PATH, 'team');
+
+/**
+ * Relative directory where completed TEAM conversation transcripts are retained.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export const AGENT_FINISHED_TEAM_CONVERSATIONS_DIRECTORY_PATH = join(AGENT_FINISHED_MESSAGES_DIRECTORY_PATH, 'team');
+
+/**
+ * Name of the JSON manifest that describes one TEAM conversation workspace.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export const AGENT_TEAM_CONVERSATION_MANIFEST_FILE_NAME = 'team.json';
+
+/**
+ * Name of the read-only teammate-source directory inside one TEAM workspace.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export const AGENT_TEAMMATE_SOURCES_DIRECTORY_NAME = 'teammates';
+
+/**
+ * One primary agent represented in a TEAM workspace manifest.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentTeamConversationPrimaryAgent = {
+    readonly permanentId: string;
+    readonly agentName: string;
+};
+
+/**
+ * One local teammate made available to the coding harness for a single user turn.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentTeamConversationTeammate = {
+    readonly permanentId: string;
+    readonly agentName: string;
+    readonly url: string;
+    readonly instructions: string;
+    readonly sourceFileName: string;
+};
+
+/**
+ * Persisted roster snapshot for the optional TEAM workspace of one queued message.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentTeamConversationWorkspaceManifest = {
+    readonly version: 1;
+    readonly primaryAgent: AgentTeamConversationPrimaryAgent;
+    readonly teammates: ReadonlyArray<AgentTeamConversationTeammate>;
+};
+
+/**
+ * Creates the stable directory name that belongs to one queued `.book` message.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function createAgentTeamConversationWorkspaceDirectoryName(messageFileName: string): string {
+    return createAgentMessageSidecarBaseName(messageFileName);
+}
+
+/**
+ * Creates the relative active workspace path for one queued message.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function createAgentTeamConversationWorkspacePath(messageFileName: string): string {
+    return join(
+        AGENT_TEAM_CONVERSATIONS_DIRECTORY_PATH,
+        createAgentTeamConversationWorkspaceDirectoryName(messageFileName),
+    );
+}
+
+/**
+ * Creates the relative completed-workspace path for one queued message.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function createFinishedAgentTeamConversationWorkspacePath(messageFileName: string): string {
+    return join(
+        AGENT_FINISHED_TEAM_CONVERSATIONS_DIRECTORY_PATH,
+        createAgentTeamConversationWorkspaceDirectoryName(messageFileName),
+    );
+}
+
+/**
+ * Creates the source-snapshot file name for one teammate.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function createAgentTeamTeammateSourceFileName(teammatePermanentId: string): string {
+    const normalizedPermanentId = teammatePermanentId
+        .trim()
+        .replace(/[^A-Za-z0-9._-]+/gu, '-')
+        .replace(/^[._-]+|[._-]+$/gu, '');
+
+    return `${normalizedPermanentId || 'teammate'}.book`;
+}
+
+/**
+ * Checks whether unknown JSON has the minimum shape required for a TEAM workspace manifest.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function isAgentTeamConversationWorkspaceManifest(
+    value: unknown,
+): value is AgentTeamConversationWorkspaceManifest {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+
+    const manifest = value as Partial<AgentTeamConversationWorkspaceManifest>;
+    if (
+        manifest.version !== 1 ||
+        !isPrimaryAgent(manifest.primaryAgent) ||
+        !Array.isArray(manifest.teammates) ||
+        !manifest.teammates.every(isTeammate)
+    ) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * Checks the primary-agent part of an untrusted manifest.
+ *
+ * @private internal utility of `isAgentTeamConversationWorkspaceManifest`
+ */
+function isPrimaryAgent(value: unknown): value is AgentTeamConversationPrimaryAgent {
+    return Boolean(
+        value &&
+            typeof value === 'object' &&
+            typeof (value as AgentTeamConversationPrimaryAgent).permanentId === 'string' &&
+            typeof (value as AgentTeamConversationPrimaryAgent).agentName === 'string',
+    );
+}
+
+/**
+ * Checks one teammate part of an untrusted manifest.
+ *
+ * @private internal utility of `isAgentTeamConversationWorkspaceManifest`
+ */
+function isTeammate(value: unknown): value is AgentTeamConversationTeammate {
+    return Boolean(
+        value &&
+            typeof value === 'object' &&
+            typeof (value as AgentTeamConversationTeammate).permanentId === 'string' &&
+            typeof (value as AgentTeamConversationTeammate).agentName === 'string' &&
+            typeof (value as AgentTeamConversationTeammate).url === 'string' &&
+            typeof (value as AgentTeamConversationTeammate).instructions === 'string' &&
+            typeof (value as AgentTeamConversationTeammate).sourceFileName === 'string',
+    );
+}

package/src/book-3.0/cliAgentEnv.ts

@@ -12,6 +12,7 @@ export const CLI_AGENT_HARNESS_NAMES = [
     'claude-code',
     'opencode',
     'gemini',
+    'qwen-code',
 ] as const;
 
 /**
@@ -24,8 +25,8 @@ export const CLI_AGENT_THINKING_LEVEL_VALUES = ['low', 'medium', 'high', 'xhigh'
 /**
  * Environment variable used as the default runner identifier when `--harness` is omitted or not set in `CliAgent`.
  *
- * Set this to one of the harness names (`openai-codex`, `github-copilot`, `cline`, `claude-code`, `opencode`, `gemini`)
- * so that `CliAgent` and `ptbk agent exec` can run without an explicit `harness` option.
+ * Set this to one of the harness names (`openai-codex`, `github-copilot`, `cline`, `claude-code`, `opencode`, `gemini`,
+ * `qwen-code`) so that `CliAgent` and `ptbk agent exec` can run without an explicit `harness` option.
  *
  * @public exported from `@promptbook/node`
  */

package/src/book-3.0/createAgentMessageSidecarBaseName.ts

@@ -0,0 +1,20 @@
+import { basename } from 'path';
+
+/**
+ * Creates the stable file-system safe base name that belongs to one queued `.book` message.
+ *
+ * Every sidecar the Agents Server prepares next to a queued message (TEAM workspaces, planned-message
+ * files, ...) derives its own name from this one normalization, so a sidecar can always be found again
+ * from the message file name alone.
+ *
+ * @param messageFileName - File name of the queued message, with or without directories.
+ * @returns Normalized base name usable as a directory or file name.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export function createAgentMessageSidecarBaseName(messageFileName: string): string {
+    const rawBaseName = basename(messageFileName).replace(/\.book$/iu, '');
+    const normalizedBaseName = rawBaseName.replace(/[^A-Za-z0-9._-]+/gu, '-').replace(/^[._-]+|[._-]+$/gu, '');
+
+    return normalizedBaseName || 'message';
+}

package/src/book-3.0/describeAgentPlannedMessageSchedule.ts

@@ -0,0 +1,94 @@
+import { formatTimeoutDurationHuman } from '../book-components/Chat/utils/timeoutToolCallPresentation';
+
+/**
+ * Schedule of one planned message as it is described to an agent.
+ *
+ * The fields match `AgentPlannedMessageSnapshot`, so one snapshot, one scheduling result, and one
+ * stored planned message are all described by the very same sentence.
+ *
+ * @private internal convention shared by the Agents Server and agent-folder runner
+ */
+export type AgentPlannedMessageScheduleDescription = {
+    readonly intervalMs?: number | null;
+    readonly cronExpression?: string | null;
+    readonly startsAt?: string | null;
+    readonly endsAt?: string | null;
+    readonly maxRunCount?: number | null;
+    readonly runCount?: number | null;
+    readonly dueAt?: string | null;
+};
+
+/**
+ * Describes one planned-message schedule in a single sentence fragment.
+ *
+ * A planned message can repeat forever, repeat a bounded number of times, run inside a date window, or
+ * wake the agent only once. Every surface showing a planned message — the wake-up itself, the goal-chat
+ * notes, the planned-message prompt section, and the model tools — describes it with this one helper,
+ * so an agent never has to reconcile two different wordings of the same plan.
+ *
+ * @param schedule - Schedule of the planned message.
+ * @returns Fragment such as `repeats every 5 minutes (2 of 10 runs done)`.
+ *
+ * @private internal utility of the Agents Server planned messages
+ */
+export function describeAgentPlannedMessageSchedule(schedule: AgentPlannedMessageScheduleDescription): string {
+    const scheduleParts = [
+        describeAgentPlannedMessageRecurrence(schedule),
+        ...describeAgentPlannedMessageBounds(schedule),
+    ];
+
+    return scheduleParts.join(', ');
+}
+
+/**
+ * Describes how often one planned message wakes the agent.
+ *
+ * @param schedule - Schedule of the planned message.
+ * @returns Recurrence fragment.
+ *
+ * @private internal utility of `describeAgentPlannedMessageSchedule`
+ */
+function describeAgentPlannedMessageRecurrence(schedule: AgentPlannedMessageScheduleDescription): string {
+    if (schedule.cronExpression) {
+        return `repeats on cron \`${schedule.cronExpression}\``;
+    }
+
+    if (schedule.intervalMs) {
+        return `repeats every ${formatTimeoutDurationHuman(schedule.intervalMs)}`;
+    }
+
+    return schedule.dueAt ? `wakes you once at ${schedule.dueAt}` : 'wakes you once';
+}
+
+/**
+ * Describes the bounds limiting how long one planned message keeps repeating.
+ *
+ * @param schedule - Schedule of the planned message.
+ * @returns Fragments for the starting date, ending date, and run count that are really set.
+ *
+ * @private internal utility of `describeAgentPlannedMessageSchedule`
+ */
+function describeAgentPlannedMessageBounds(schedule: AgentPlannedMessageScheduleDescription): Array<string> {
+    const bounds: Array<string> = [];
+    const runCount = schedule.runCount || 0;
+
+    if (schedule.startsAt) {
+        bounds.push(`starting ${schedule.startsAt}`);
+    }
+
+    if (schedule.endsAt) {
+        bounds.push(`until ${schedule.endsAt}`);
+    }
+
+    if (schedule.maxRunCount) {
+        bounds.push(`${runCount} of ${schedule.maxRunCount} runs done`);
+    } else if (runCount > 0) {
+        bounds.push(`${runCount} run${runCount === 1 ? '' : 's'} done`);
+    }
+
+    if ((schedule.cronExpression || schedule.intervalMs) && schedule.dueAt) {
+        bounds.push(`next at ${schedule.dueAt}`);
+    }
+
+    return bounds;
+}

package/src/book-components/BookEditor/BookEditorMonaco.tsx

@@ -15,6 +15,8 @@ import { BookEditorMonacoConstants } from './BookEditorMonacoConstants';
 import { BookEditorMonacoUploadPanel } from './BookEditorMonacoUploadPanel';
 import { BOOK_EDITOR_RENDER_THEME, resolveBookEditorRenderTheme } from './BookEditorTheme';
 import { createDeprecatedCommitmentDiagnostics } from './createDeprecatedCommitmentDiagnostics.browser';
+import { createDuplicateFromCommitmentDiagnostics } from './createDuplicateFromCommitmentDiagnostics';
+import { createUnknownCommitmentDiagnostics } from './createUnknownCommitmentDiagnostics';
 import { useBookEditorMonacoDecorations } from './useBookEditorMonacoDecorations';
 import { useBookEditorMonacoDiagnostics } from './useBookEditorMonacoDiagnostics';
 import { useBookEditorMonacoInteractions } from './useBookEditorMonacoInteractions';
@@ -257,7 +259,12 @@ export function BookEditorMonaco(props: BookEditorProps) {
         editor,
         handleFiles,
     });
-    const combinedDiagnostics = [...(diagnostics || []), ...createDeprecatedCommitmentDiagnostics(value)];
+    const combinedDiagnostics = [
+        ...(diagnostics || []),
+        ...createDeprecatedCommitmentDiagnostics(value),
+        ...createUnknownCommitmentDiagnostics(value),
+        ...createDuplicateFromCommitmentDiagnostics(value),
+    ];
     const isActionBarVisible = isBookEditorMonacoActionbarVisible({
         hoistedMenuItems,
         isUploadButtonShown,

package/src/book-components/BookEditor/BookEditorMonacoTokenization.ts

@@ -1,3 +1,5 @@
+import { createBookCommitmentLineTypeRegex } from '../../book-2.0/agent-source/getBookCommitmentLineType';
+
 /**
  * Regex source for absolute URL references inside TEAM/FROM/IMPORT commitments.
  *
@@ -47,7 +49,7 @@ const AGENT_REFERENCE_COMMITMENT_TYPES = ['FROM', 'IMPORT', 'IMPORTS', 'TEAM'] a
  *
  * @private function of BookEditorMonaco
  */
-const DYNAMIC_COMMITMENT_REGEX = /^\s*[A-Z][A-Z0-9]+(?:\s+[A-Z][A-Z0-9]+)*(?=\s|$)/;
+const DYNAMIC_COMMITMENT_REGEX = createBookCommitmentLineTypeRegex();
 
 /**
  * Regex pattern to match horizontal lines.

package/src/book-components/BookEditor/createDeprecatedCommitmentDiagnostics.browser.ts

@@ -1,11 +1,3 @@
-/**
- * Browser-compatible stub for `createDeprecatedCommitmentDiagnostics`.
- *
- * In the browser build the full Node.js implementation is not available,
- * so this stub always returns an empty array to keep the editor functional.
- *
- * @private internal utility of `BookEditorMonaco`
- */
-export function createDeprecatedCommitmentDiagnostics(_agentSource?: string): [] {
-    return [];
-}
+// The Book editor already uses the commitment parser in the browser for other
+// diagnostics, so reuse the same catalog-driven implementation here as well.
+export { createDeprecatedCommitmentDiagnostics } from './createDeprecatedCommitmentDiagnostics';