dominds 1.28.0 → 1.29.0

package/dist/llm/gen/mock.js

@@ -428,6 +428,9 @@ responses:
         else if (matched && matched.usage) {
             const promptTokens = matched.usage.promptTokens;
             const completionTokens = typeof matched.usage.completionTokens === 'number' ? matched.usage.completionTokens : 0;
+            const reasoningTokens = typeof matched.usage.reasoningTokens === 'number'
+                ? matched.usage.reasoningTokens
+                : undefined;
             const totalTokens = typeof matched.usage.totalTokens === 'number'
                 ? matched.usage.totalTokens
                 : promptTokens + completionTokens;
@@ -435,6 +438,7 @@ responses:
                 kind: 'available',
                 promptTokens,
                 completionTokens,
+                ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
                 totalTokens,
             };
         }
@@ -547,6 +551,9 @@ responses:
             else if (matched && matched.usage) {
                 const promptTokens = matched.usage.promptTokens;
                 const completionTokens = typeof matched.usage.completionTokens === 'number' ? matched.usage.completionTokens : 0;
+                const reasoningTokens = typeof matched.usage.reasoningTokens === 'number'
+                    ? matched.usage.reasoningTokens
+                    : undefined;
                 const totalTokens = typeof matched.usage.totalTokens === 'number'
                     ? matched.usage.totalTokens
                     : promptTokens + completionTokens;
@@ -554,6 +561,7 @@ responses:
                     kind: 'available',
                     promptTokens,
                     completionTokens,
+                    ...(reasoningTokens === undefined ? {} : { reasoningTokens }),
                     totalTokens,
                 };
             }

package/dist/llm/gen/openai-compatible.js

@@ -777,12 +777,17 @@ function tryExtractChatUsage(usage) {
     const prompt = usage.prompt_tokens;
     const completion = usage.completion_tokens;
     const total = usage.total_tokens;
+    const completionDetails = usage.completion_tokens_details;
     if (typeof prompt !== 'number' || typeof completion !== 'number')
         return { kind: 'unavailable' };
+    const reasoningTokens = isRecord(completionDetails)
+        ? completionDetails.reasoning_tokens
+        : undefined;
     return {
         kind: 'available',
         promptTokens: prompt,
         completionTokens: completion,
+        ...(typeof reasoningTokens === 'number' ? { reasoningTokens } : {}),
         totalTokens: typeof total === 'number' ? total : prompt + completion,
     };
 }

package/dist/llm/gen/openai.js

@@ -600,13 +600,18 @@ function parseOpenAiUsage(usage) {
     const inputTokens = usage.input_tokens;
     const outputTokens = usage.output_tokens;
     const totalTokens = usage.total_tokens;
+    const outputTokensDetails = usage.output_tokens_details;
     if (typeof inputTokens !== 'number' || typeof outputTokens !== 'number') {
         return { kind: 'unavailable' };
     }
+    const reasoningTokens = isRecord(outputTokensDetails)
+        ? outputTokensDetails.reasoning_tokens
+        : undefined;
     return {
         kind: 'available',
         promptTokens: inputTokens,
         completionTokens: outputTokens,
+        ...(typeof reasoningTokens === 'number' ? { reasoningTokens } : {}),
         totalTokens: typeof totalTokens === 'number' ? totalTokens : inputTokens + outputTokens,
     };
 }
@@ -654,12 +659,15 @@ function buildOpenAiReasoning(openAiParams) {
         return undefined;
     }
     const summary = openAiParams.reasoning_summary === 'none' ? null : openAiParams.reasoning_summary;
-    return {
+    const reasoning = {
         ...(openAiParams.reasoning_effort !== undefined
             ? { effort: openAiParams.reasoning_effort }
             : {}),
         ...(summary !== undefined ? { summary } : {}),
     };
+    // OpenAI SDK 6.42.0 predates the GPT-5.6 `max` effort literal exposed by the current
+    // API model catalog. Keep the widening isolated at this external SDK boundary.
+    return reasoning;
 }
 function buildOpenAiNativeTools(openAiParams) {
     const enabled = openAiParams.web_search_tool === true ||

package/dist/llm/gen/registry.js

@@ -6,6 +6,7 @@ exports.unregisterLlmGenerator = unregisterLlmGenerator;
 exports.getLlmGenerator = getLlmGenerator;
 const anthropic_1 = require("./anthropic");
 const codex_1 = require("./codex");
+const google_1 = require("./google");
 const mock_1 = require("./mock");
 const openai_1 = require("./openai");
 const openai_compatible_1 = require("./openai-compatible");
@@ -20,10 +21,11 @@ function getLlmGenerator(apiType) {
     return exports.generatorsRegistry.get(apiType);
 }
 (function initializeBuiltins() {
+    registerLlmGenerator(new mock_1.MockGen());
     registerLlmGenerator(new anthropic_1.AnthropicGen());
     registerLlmGenerator(new anthropic_1.AnthropicGen('anthropic-compatible'));
-    registerLlmGenerator(new codex_1.CodexGen());
-    registerLlmGenerator(new mock_1.MockGen());
     registerLlmGenerator(new openai_1.OpenAiGen());
     registerLlmGenerator(new openai_compatible_1.OpenAiCompatibleGen());
+    registerLlmGenerator(new codex_1.CodexGen());
+    registerLlmGenerator(new google_1.GoogleGen());
 })();

package/dist/llm/gen/tool-output-limit.js

@@ -8,6 +8,7 @@ const DEFAULT_PROVIDER_TOOL_OUTPUT_CHAR_LIMITS = {
     'openai-compatible': 4 * 1024 * 1024,
     anthropic: 4 * 1024 * 1024,
     'anthropic-compatible': 4 * 1024 * 1024,
+    google: 4 * 1024 * 1024,
     mock: 8 * 1024 * 1024,
 };
 function buildProviderToolOutputSuffix(originalChars, limitChars) {

package/dist/llm/gen/tool-result-image-ingest.d.ts

@@ -14,6 +14,7 @@ export declare const OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
 export declare const OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
 export declare const CODEX_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
 export declare const ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
+export declare const GEMINI_TOOL_RESULT_IMAGE_BUDGET_BYTES: number;
 export declare function resolveModelImageInputSupport(modelInfo: ModelInfo | undefined, defaultValue: boolean): boolean;
 export declare function buildImageBudgetLimitDetail(args: {
     byteLength: number;

package/dist/llm/gen/tool-result-image-ingest.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.CODEX_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES = void 0;
+exports.GEMINI_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.CODEX_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES = exports.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES = void 0;
 exports.resolveModelImageInputSupport = resolveModelImageInputSupport;
 exports.buildImageBudgetLimitDetail = buildImageBudgetLimitDetail;
 exports.buildImageBudgetKeyForContentItem = buildImageBudgetKeyForContentItem;
@@ -24,6 +24,7 @@ exports.OPENAI_TOOL_RESULT_IMAGE_BUDGET_BYTES = 50 * 1024 * 1024;
 exports.OPENAI_COMPATIBLE_TOOL_RESULT_IMAGE_BUDGET_BYTES = 50 * 1024 * 1024;
 exports.CODEX_TOOL_RESULT_IMAGE_BUDGET_BYTES = 50 * 1024 * 1024;
 exports.ANTHROPIC_TOOL_RESULT_IMAGE_BUDGET_BYTES = 32 * 1024 * 1024;
+exports.GEMINI_TOOL_RESULT_IMAGE_BUDGET_BYTES = 20 * 1024 * 1024;
 function resolveModelImageInputSupport(modelInfo, defaultValue) {
     const value = modelInfo?.['supports_image_input'];
     if (value === undefined)

package/dist/llm/kernel-driver/drive.js

@@ -793,7 +793,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
             '',
             '不要再尝试获取各种大段的输出，都不会显示给你。现在先做两件事：',
             '1. 把下一程对话需要知道的此程细节信息写入差遣牒合适章节。',
-            '2. 对于不适合差遣牒章节覆盖、但下一程恢复当前对话需要的信息，用当前对话范围（scope=dialog）提醒项写明本路对话任务目标并带过桥。',
+            '2. 先看固定“本路主线目标”提醒；它要求先问人类就立即问，并用 set_dialog_goal 记录答案。对于不适合差遣牒章节覆盖、但下一程恢复当前对话需要的信息，用当前对话范围（scope=dialog）提醒项带过桥。',
             '',
             '然后调用 clear_mind({}) 开启新一程。',
             '',
@@ -818,7 +818,7 @@ function formatContextHealthLargeToolReturnUnavailable(args) {
         '',
         'Do not try again to fetch any kind of large output; it still will not be shown. Do two things now:',
         '1. Write the details from this course that the next course needs into the appropriate Taskdoc sections.',
-        '2. For information that does not fit a Taskdoc section but is needed to resume this dialog in the next course, use current-dialog scoped (scope=dialog) reminders to state this dialog task goal and carry it over.',
+        '2. First read the fixed Main Dialog goal reminder. If it says to ask the human, ask and record the answer with set_dialog_goal. For information that does not fit a Taskdoc section but is needed to resume this dialog in the next course, use current-dialog scoped (scope=dialog) reminders to carry it over.',
         '',
         'Then call clear_mind({}) to start a new course.',
         '',
@@ -922,13 +922,28 @@ function mergeTellaskVirtualTools(baseTools, options) {
     return merged;
 }
 function computeContextHealthSnapshot(args) {
+    const usageFields = args.usage.kind === 'available'
+        ? {
+            promptTokens: args.usage.promptTokens,
+            completionTokens: args.usage.completionTokens,
+            ...(typeof args.usage.reasoningTokens === 'number'
+                ? { reasoningTokens: args.usage.reasoningTokens }
+                : {}),
+            totalTokens: args.usage.totalTokens,
+        }
+        : {};
     const modelInfo = args.providerCfg.models[args.model];
     const modelContextWindowText = modelInfo && typeof modelInfo.context_window === 'string'
         ? modelInfo.context_window
         : undefined;
     const modelContextLimitTokens = resolveModelContextLimitTokens(modelInfo);
     if (modelContextLimitTokens === null) {
-        return { kind: 'unavailable', reason: 'model_limit_unavailable', modelContextWindowText };
+        return {
+            kind: 'unavailable',
+            reason: 'model_limit_unavailable',
+            ...usageFields,
+            modelContextWindowText,
+        };
     }
     const { effectiveOptimalMaxTokens, optimalMaxTokensConfigured, effectiveCriticalMaxTokens, criticalMaxTokensConfigured, } = resolveEffectiveTokenThresholds({
         modelInfo,
@@ -957,6 +972,9 @@ function computeContextHealthSnapshot(args) {
         kind: 'available',
         promptTokens: args.usage.promptTokens,
         completionTokens: args.usage.completionTokens,
+        ...(typeof args.usage.reasoningTokens === 'number'
+            ? { reasoningTokens: args.usage.reasoningTokens }
+            : {}),
         totalTokens: args.usage.totalTokens,
         modelContextWindowText,
         modelContextLimitTokens,

package/dist/main-dialog-goal-reminder.d.ts

@@ -0,0 +1,20 @@
+import type { Dialog } from './dialog';
+import { type Reminder } from './tool';
+export declare const MAIN_DIALOG_GOAL_REMINDER_ID = "mainDialogGoal";
+export type SetMainDialogGoalRequest = Readonly<{
+    mode: 'goal';
+    goal: string;
+}> | Readonly<{
+    mode: 'follow_taskdoc';
+}>;
+export type SetMainDialogGoalResult = Readonly<{
+    kind: 'updated';
+    reminder: Reminder;
+}> | Readonly<{
+    kind: 'rejected_parallel_dialogs';
+    reminder: Reminder;
+}>;
+export declare function ensureMainDialogGoalReminder(dlg: Dialog): Promise<boolean>;
+export declare function reconcileMainDialogGoalReminderForKnownParallelState(dlg: Dialog, hasParallelDialogs: boolean): boolean;
+export declare function refreshFollowTaskdocMainDialogGoalReminderForKnownParallelState(dlg: Dialog): boolean;
+export declare function setMainDialogGoalReminder(dlg: Dialog, request: SetMainDialogGoalRequest): Promise<SetMainDialogGoalResult>;

package/dist/main-dialog-goal-reminder.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAIN_DIALOG_GOAL_REMINDER_ID = void 0;
+exports.ensureMainDialogGoalReminder = ensureMainDialogGoalReminder;
+exports.reconcileMainDialogGoalReminderForKnownParallelState = reconcileMainDialogGoalReminderForKnownParallelState;
+exports.refreshFollowTaskdocMainDialogGoalReminderForKnownParallelState = refreshFollowTaskdocMainDialogGoalReminderForKnownParallelState;
+exports.setMainDialogGoalReminder = setMainDialogGoalReminder;
+const time_1 = require("@longrun-ai/kernel/utils/time");
+const work_language_1 = require("./runtime/work-language");
+const tool_1 = require("./tool");
+exports.MAIN_DIALOG_GOAL_REMINDER_ID = 'mainDialogGoal';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isMainDialog(dlg) {
+    return dlg.id.selfId === dlg.id.rootId;
+}
+function parseMainDialogGoalMeta(meta) {
+    if (!isRecord(meta)) {
+        return undefined;
+    }
+    if (meta['kind'] !== 'main_dialog_goal') {
+        return undefined;
+    }
+    const mode = meta['mode'];
+    if (mode !== 'requires_human_confirmation' &&
+        mode !== 'specific_goal' &&
+        mode !== 'follow_taskdoc') {
+        throw new Error(`Invalid main-dialog goal reminder mode: ${String(mode)}`);
+    }
+    const goal = meta['goal'];
+    const specificGoal = mode === 'specific_goal' && typeof goal === 'string' ? goal : undefined;
+    if (mode === 'specific_goal') {
+        if (specificGoal === undefined || specificGoal.trim() === '') {
+            throw new Error('Invalid main-dialog goal reminder meta: specific_goal requires goal');
+        }
+    }
+    else if (goal !== undefined) {
+        throw new Error('Invalid main-dialog goal reminder meta: goal is only valid for specific_goal');
+    }
+    const updatedAt = meta['updatedAt'];
+    if (typeof updatedAt !== 'string' || updatedAt.trim() === '') {
+        throw new Error('Invalid main-dialog goal reminder meta: updatedAt required');
+    }
+    const update = meta['update'];
+    if (!isRecord(update) || typeof update['altInstruction'] !== 'string') {
+        throw new Error('Invalid main-dialog goal reminder meta: update.altInstruction required');
+    }
+    const deleteValue = meta['delete'];
+    if (!isRecord(deleteValue) || typeof deleteValue['altInstruction'] !== 'string') {
+        throw new Error('Invalid main-dialog goal reminder meta: delete.altInstruction required');
+    }
+    const base = {
+        kind: 'main_dialog_goal',
+        updatedAt,
+        update: { altInstruction: update['altInstruction'] },
+        delete: { altInstruction: deleteValue['altInstruction'] },
+    };
+    switch (mode) {
+        case 'requires_human_confirmation':
+            return { ...base, mode };
+        case 'follow_taskdoc':
+            return { ...base, mode };
+        case 'specific_goal': {
+            if (specificGoal === undefined) {
+                throw new Error('Invalid main-dialog goal reminder meta: specific_goal requires goal');
+            }
+            return { ...base, mode, goal: specificGoal };
+        }
+    }
+}
+function mainDialogGoalMaintenanceInstruction() {
+    return ('set_dialog_goal({ "mode": "goal", "goal": "..." }) ' +
+        'or set_dialog_goal({ "mode": "follow_taskdoc" })');
+}
+function buildMainDialogGoalMeta(args) {
+    if (args.mode === 'specific_goal') {
+        if (args.goal.trim() === '') {
+            throw new Error('Main-dialog goal reminder specific_goal meta requires a non-empty goal');
+        }
+    }
+    else if ('goal' in args && args.goal !== undefined) {
+        throw new Error('Main-dialog goal reminder goal is only valid for specific_goal meta');
+    }
+    const instruction = mainDialogGoalMaintenanceInstruction();
+    const base = {
+        kind: 'main_dialog_goal',
+        updatedAt: args.updatedAt ?? (0, time_1.formatUnifiedTimestamp)(new Date()),
+        update: { altInstruction: instruction },
+        delete: { altInstruction: instruction },
+    };
+    switch (args.mode) {
+        case 'requires_human_confirmation':
+            return { ...base, mode: args.mode };
+        case 'follow_taskdoc':
+            return { ...base, mode: args.mode };
+        case 'specific_goal':
+            return { ...base, mode: args.mode, goal: args.goal };
+    }
+}
+function formatMainDialogGoalContent(language, meta, hasParallelDialogs) {
+    if (language === 'zh') {
+        switch (meta.mode) {
+            case 'specific_goal':
+                return `本路主线目标：\n${meta.goal}`;
+            case 'follow_taskdoc':
+                return hasParallelDialogs
+                    ? [
+                        '本路主线目标：依差遣牒推进。',
+                        'Dominds 已确认：这个智能体现在还有其它并行对话。不能只按差遣牒继续；请立即问人类：这一路主线接下来具体推进什么？得到答案后用 set_dialog_goal 记录。',
+                    ].join('\n')
+                    : [
+                        '本路主线目标：依差遣牒推进。',
+                        'Dominds 已确认：当前这个智能体只有这一条对话，可以按差遣牒继续。若以后出现同智能体并行对话，Dominds 会在这条提醒上补充“先问人类”。',
+                    ].join('\n');
+            case 'requires_human_confirmation':
+                return hasParallelDialogs
+                    ? [
+                        '本路主线目标：未设置。',
+                        'Dominds 已确认：这个智能体现在有其它并行对话。请立即问人类：这一路主线接下来具体推进什么？得到答案后用 set_dialog_goal 记录。',
+                    ].join('\n')
+                    : [
+                        '本路主线目标：未设置。',
+                        '请立即问人类：这一路主线接下来具体推进什么？得到答案后用 set_dialog_goal 记录。',
+                    ].join('\n');
+        }
+    }
+    switch (meta.mode) {
+        case 'specific_goal':
+            return `Goal for this Main Dialog:\n${meta.goal}`;
+        case 'follow_taskdoc':
+            return hasParallelDialogs
+                ? [
+                    'Goal for this Main Dialog: proceed from the Taskdoc.',
+                    'Dominds has confirmed that this agent now has another parallel dialog. Do not continue from the Taskdoc alone. Ask the human immediately: what should this Main Dialog work on next? Then record the answer with set_dialog_goal.',
+                ].join('\n')
+                : [
+                    'Goal for this Main Dialog: proceed from the Taskdoc.',
+                    'Dominds has confirmed that this agent has only one dialog right now, so following the Taskdoc is enough. If another parallel dialog appears for this agent, Dominds will add an "ask the human first" note to this reminder.',
+                ].join('\n');
+        case 'requires_human_confirmation':
+            return hasParallelDialogs
+                ? [
+                    'Goal for this Main Dialog: not set.',
+                    'Dominds has confirmed that this agent now has another parallel dialog. Ask the human immediately: what should this Main Dialog work on next? Then record the answer with set_dialog_goal.',
+                ].join('\n')
+                : [
+                    'Goal for this Main Dialog: not set.',
+                    'Ask the human immediately: what should this Main Dialog work on next? Then record the answer with set_dialog_goal.',
+                ].join('\n');
+    }
+}
+function buildMainDialogGoalReminder(args) {
+    return (0, tool_1.materializeReminder)({
+        id: exports.MAIN_DIALOG_GOAL_REMINDER_ID,
+        content: formatMainDialogGoalContent(args.language, args.meta, args.hasParallelDialogs),
+        meta: args.meta,
+        echoback: true,
+        scope: 'dialog',
+        createdAt: args.existing?.createdAt ?? args.meta.updatedAt,
+        priority: 'high',
+        renderMode: 'markdown',
+    });
+}
+function mainDialogGoalMetaEquals(value, expected) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const actual = parseMainDialogGoalMeta(value);
+    const expectedKeys = expected.goal === undefined
+        ? ['delete', 'kind', 'mode', 'update', 'updatedAt']
+        : ['delete', 'goal', 'kind', 'mode', 'update', 'updatedAt'];
+    return (actual !== undefined &&
+        Object.keys(value).sort().join('\0') === expectedKeys.sort().join('\0') &&
+        actual.mode === expected.mode &&
+        actual.goal === expected.goal &&
+        actual.updatedAt === expected.updatedAt &&
+        actual.update.altInstruction === expected.update.altInstruction &&
+        actual.delete.altInstruction === expected.delete.altInstruction);
+}
+function reminderMatchesMainDialogGoalState(existing, next, meta) {
+    return (existing.content === next.content &&
+        mainDialogGoalMetaEquals(existing.meta, meta) &&
+        existing.echoback === true &&
+        existing.scope === next.scope &&
+        existing.renderMode === next.renderMode &&
+        existing.priority === next.priority);
+}
+function findMainDialogGoalReminderIndex(reminders) {
+    let foundIndex;
+    for (let index = 0; index < reminders.length; index += 1) {
+        const reminder = reminders[index];
+        if (reminder === undefined) {
+            continue;
+        }
+        const meta = parseMainDialogGoalMeta(reminder.meta);
+        const hasFixedId = reminder.id === exports.MAIN_DIALOG_GOAL_REMINDER_ID;
+        if (hasFixedId && meta === undefined) {
+            throw new Error(`Reminder id ${exports.MAIN_DIALOG_GOAL_REMINDER_ID} is reserved for the main-dialog goal reminder`);
+        }
+        if (meta !== undefined && !hasFixedId) {
+            throw new Error(`Main-dialog goal reminder must use id ${exports.MAIN_DIALOG_GOAL_REMINDER_ID}; got ${reminder.id}`);
+        }
+        if (!hasFixedId) {
+            continue;
+        }
+        if (reminder.scope !== 'dialog') {
+            throw new Error('Main-dialog goal reminder must be dialog-scoped');
+        }
+        if (foundIndex !== undefined) {
+            throw new Error(`Duplicate main-dialog goal reminder detected in dialog-local reminders`);
+        }
+        foundIndex = index;
+    }
+    return foundIndex;
+}
+async function countRunningDialogsForAgentIncludingCurrent(dlg) {
+    if (dlg.status !== 'running') {
+        return 1;
+    }
+    const { globalDialogRegistry } = await import('./dialog-global-registry.js');
+    const runningDialogs = globalDialogRegistry.getRunningDialogsByAgent(dlg.agentId);
+    const includesCurrent = runningDialogs.some((candidate) => candidate.id.equals(dlg.id));
+    return runningDialogs.length + (includesCurrent ? 0 : 1);
+}
+async function hasParallelRunningDialogsForAgent(dlg) {
+    return (await countRunningDialogsForAgentIncludingCurrent(dlg)) > 1;
+}
+function normalizeExistingMetaForReconcile(args) {
+    const existingMeta = parseMainDialogGoalMeta(args.existing?.meta);
+    if (existingMeta === undefined) {
+        return buildMainDialogGoalMeta({
+            mode: 'requires_human_confirmation',
+        });
+    }
+    return existingMeta;
+}
+function upsertMainDialogGoalReminder(args) {
+    const index = findMainDialogGoalReminderIndex(args.dlg.reminders);
+    if (index === undefined) {
+        const next = buildMainDialogGoalReminder({
+            meta: args.meta,
+            language: (0, work_language_1.getWorkLanguage)(),
+            hasParallelDialogs: args.hasParallelDialogs,
+        });
+        args.dlg.reminders.unshift(next);
+        args.dlg.touchReminders();
+        return { changed: true, reminder: next };
+    }
+    const existing = args.dlg.reminders[index];
+    if (existing === undefined) {
+        throw new Error(`Main-dialog goal reminder index ${index} disappeared before update`);
+    }
+    const next = buildMainDialogGoalReminder({
+        existing,
+        meta: args.meta,
+        language: (0, work_language_1.getWorkLanguage)(),
+        hasParallelDialogs: args.hasParallelDialogs,
+    });
+    if (reminderMatchesMainDialogGoalState(existing, next, args.meta)) {
+        return { changed: false, reminder: existing };
+    }
+    args.dlg.reminders[index] = next;
+    args.dlg.touchReminders();
+    return { changed: true, reminder: next };
+}
+async function ensureMainDialogGoalReminder(dlg) {
+    if (!isMainDialog(dlg)) {
+        return false;
+    }
+    const hasParallelDialogs = await hasParallelRunningDialogsForAgent(dlg);
+    return reconcileMainDialogGoalReminderForKnownParallelState(dlg, hasParallelDialogs);
+}
+function reconcileMainDialogGoalReminderForKnownParallelState(dlg, hasParallelDialogs) {
+    if (!isMainDialog(dlg)) {
+        return false;
+    }
+    const index = findMainDialogGoalReminderIndex(dlg.reminders);
+    const existing = index === undefined ? undefined : dlg.reminders[index];
+    const meta = normalizeExistingMetaForReconcile({
+        existing,
+    });
+    return upsertMainDialogGoalReminder({ dlg, meta, hasParallelDialogs }).changed;
+}
+function refreshFollowTaskdocMainDialogGoalReminderForKnownParallelState(dlg) {
+    if (!isMainDialog(dlg)) {
+        return false;
+    }
+    const index = findMainDialogGoalReminderIndex(dlg.reminders);
+    if (index === undefined) {
+        return false;
+    }
+    const existing = dlg.reminders[index];
+    if (existing === undefined) {
+        throw new Error(`Main-dialog goal reminder index ${index} disappeared before parallel marking`);
+    }
+    const existingMeta = parseMainDialogGoalMeta(existing.meta);
+    if (existingMeta?.mode !== 'follow_taskdoc') {
+        return false;
+    }
+    return upsertMainDialogGoalReminder({
+        dlg,
+        meta: existingMeta,
+        hasParallelDialogs: true,
+    }).changed;
+}
+async function setMainDialogGoalReminder(dlg, request) {
+    if (!isMainDialog(dlg)) {
+        throw new Error('setMainDialogGoalReminder is only valid for Main Dialogs');
+    }
+    const hasParallelDialogs = await hasParallelRunningDialogsForAgent(dlg);
+    if (request.mode === 'follow_taskdoc' && hasParallelDialogs) {
+        const rejected = upsertMainDialogGoalReminder({
+            dlg,
+            meta: buildMainDialogGoalMeta({
+                mode: 'follow_taskdoc',
+            }),
+            hasParallelDialogs,
+        });
+        return { kind: 'rejected_parallel_dialogs', reminder: rejected.reminder };
+    }
+    if (request.mode === 'follow_taskdoc') {
+        return {
+            kind: 'updated',
+            reminder: upsertMainDialogGoalReminder({
+                dlg,
+                meta: buildMainDialogGoalMeta({ mode: 'follow_taskdoc' }),
+                hasParallelDialogs,
+            }).reminder,
+        };
+    }
+    const goal = request.goal.trim();
+    if (goal === '') {
+        throw new Error('setMainDialogGoalReminder requires a non-empty goal');
+    }
+    return {
+        kind: 'updated',
+        reminder: upsertMainDialogGoalReminder({
+            dlg,
+            meta: buildMainDialogGoalMeta({ mode: 'specific_goal', goal }),
+            hasParallelDialogs,
+        }).reminder,
+    };
+}