dominds 0.10.0 → 0.10.1

package/dist/docs/fbr.md

@@ -9,7 +9,7 @@ Chinese version: [中文版](./fbr.zh.md)
 **Fresh Boots Reasoning (FBR)** is a Dominds mechanism for “reasoning again from a clean slate” on a bounded sub-problem,
 then reporting back to the tellasker dialog.
 
-In Dominds, FBR is triggered by the dedicated function tool `freshBootsReasoning({ tellaskContent: "..." })`.
+In Dominds, FBR is triggered by the dedicated function tool `freshBootsReasoning({ tellaskContent: "...", effort?: N })`.
 The mechanism is the runtime-enforced contract applied to the spawned sideline dialog.
 
 ## 2. Design principles and tradeoffs
@@ -29,7 +29,7 @@ silent ignore is worse than an error.
 
 ### 2.3 Serial multi-pass reasoning, not “multi-agent collaboration”
 
-`fbr-effort` is for producing multiple rounds in sequence inside a **single FBR sideline conversation window**. The tellasker dialog is responsible for distilling the results; rounds do not coordinate with each other.
+`fbr-effort` is an FBR intensity setting. Runtime interprets intensity `N` as `N` serial passes inside a **single FBR sideline conversation window**. The tellasker dialog is responsible for distilling the results; passes do not coordinate with each other.
 
 ## 3. User syntax
 
@@ -37,16 +37,18 @@ silent ignore is worse than an error.
 
 Use the dedicated FBR form:
 
-- `freshBootsReasoning({ tellaskContent: "..." })`
+- `freshBootsReasoning({ tellaskContent: "...", effort?: N })`
 
 Notes:
 
 - FBR does not use `targetAgentId`, `sessionSlug`, or `mentionList`.
 - `tellaskContent` is the authoritative task context for the FBR sideline.
+- `effort` is optional and sets per-call FBR intensity; when omitted, runtime uses the current member’s `fbr-effort`.
+- Intensity `N` maps to `N` serial FBR passes inside one sideline window.
 
 ### 3.2 Scope
 
-This document specifies the FBR mechanism and its `freshBootsReasoning({ tellaskContent: "..." })` contract. General teammate Tellasks (`tellaskSessionless({ targetAgentId: "<teammate>", tellaskContent: "..." })`) follow
+This document specifies the FBR mechanism and its `freshBootsReasoning({ tellaskContent: "...", effort?: N })` contract. General teammate Tellasks (`tellaskSessionless({ targetAgentId: "<teammate>", tellaskContent: "..." })`) follow
 the taxonomy and capability model in [`dialog-system.md`](./dialog-system.md).
 
 If you want a “fresh” sideline dialog that still has tools, use an explicit teammate identity via the general teammate Tellask flow.
@@ -144,8 +146,8 @@ An FBR sideline dialog should produce per-round conclusions that are easy to dis
 
 - Type: integer
 - Default: `3`
-- `0`: disable `freshBootsReasoning({ tellaskContent: "..." })` FBR for that member (runtime MUST reject `freshBootsReasoning({ tellaskContent: "..." })` clearly)
-- `1..100`: run N FBR rounds sequentially inside one sideline dialog per `freshBootsReasoning({ tellaskContent: "..." })`
+- `0`: disable FBR by default for that member (runtime MUST reject when effective effort is `0`)
+- `1..100`: valid intensity range (effective effort comes from explicit `effort` or fallback `fbr-effort`)
 - `> 100` / non-integer / negative: validation error (reject; no clamping)
 
 When `fbr-effort = N`:

package/dist/docs/fbr.zh.md

@@ -8,7 +8,7 @@
 
 **扪心自问（FBR, Fresh Boots Reasoning）** 是 Dominds 的一种工作机制：在诉请者对话推进过程中，智能体可以把一个边界清晰的子问题“拆出去”，以 **更干净的上下文** 重新推理一次，然后把结论回贴到诉请者对话中。
 
-在 Dominds 里，FBR 通过专用函数工具 `freshBootsReasoning({ tellaskContent: "..." })` 触发；FBR 的核心是运行时对该支线对话施加的一组强制约束与串行语义。
+在 Dominds 里，FBR 通过专用函数工具 `freshBootsReasoning({ tellaskContent: "...", effort?: N })` 触发；FBR 的核心是运行时对该支线对话施加的一组强制约束与串行语义。
 
 ## 2. 设计原则与取舍（为什么这样做）
 
@@ -27,7 +27,7 @@ FBR 的价值来自“把推理拉回文本”：让被诉请者只围绕诉请
 
 ### 2.3 串行多轮推理，而不是“多代理协作”
 
-`fbr-effort` 表示一条 FBR 请求在同一次触发内会在**单一子对话窗口**内执行**串行多轮**推理，由诉请者对话负责综合提炼。不同轮次不协作，仅做不同视角的顺序补充。
+`fbr-effort` 是 FBR 的力度设置。运行时会把力度 `N` 解释为在**单一子对话窗口**内执行 `N` 次串行推理，由诉请者对话负责综合提炼。不同轮次不协作，仅做不同视角的顺序补充。
 
 ## 3. 用户语法
 
@@ -35,16 +35,18 @@ FBR 的价值来自“把推理拉回文本”：让被诉请者只围绕诉请
 
 触发 FBR 的语法只有一种：
 
-- `freshBootsReasoning({ tellaskContent: "..." })`
+- `freshBootsReasoning({ tellaskContent: "...", effort?: N })`
 
 说明：
 
 - FBR 不使用 `targetAgentId`、`sessionSlug`、`mentionList`。
 - `tellaskContent` 是 FBR 支线的权威任务上下文。
+- `effort` 为可选，用于设置本次调用的 FBR 力度；未传时运行时回退到当前成员 `fbr-effort`。
+- 力度 `N` 会映射为同一 FBR 支线窗口内的 `N` 次串行推理。
 
 ### 3.2 作用域
 
-本文档只定义 **FBR 机制**，并说明其通过 `freshBootsReasoning({ tellaskContent: "..." })` 触发的行为契约。一般的队友诉请（`tellaskSessionless({ targetAgentId: "<teammate>", tellaskContent: "..." })`）仍按 [`dialog-system.zh.md`](./dialog-system.zh.md) 的 Tellask 分类与能力模型执行。
+本文档只定义 **FBR 机制**，并说明其通过 `freshBootsReasoning({ tellaskContent: "...", effort?: N })` 触发的行为契约。一般的队友诉请（`tellaskSessionless({ targetAgentId: "<teammate>", tellaskContent: "..." })`）仍按 [`dialog-system.zh.md`](./dialog-system.zh.md) 的 Tellask 分类与能力模型执行。
 
 如果你需要“同人设但可用工具”的支线对话，请使用一般队友诉请路径，并显式指定队友身份。
 
@@ -139,8 +141,8 @@ FBR 支线对话应产出一份便于诉请者整合的简明推理结果。单
 
 - 类型：整数
 - 默认：`3`
-- `0`：禁用该成员的 `freshBootsReasoning({ tellaskContent: "..." })` FBR（必须明确报错拒绝）
-- `1..100`：每次 `freshBootsReasoning({ tellaskContent: "..." })` 在单一 FBR 子对话内执行 N 轮顺序推理
+- `0`：该成员默认禁用 FBR（当有效力度为 `0` 时必须明确报错拒绝）
+- `1..100`：力度取值范围（有效力度来自显式 `effort`，未传时回退 `fbr-effort`）
 - `> 100` / 非整数 / 负数：配置错误（直接报错，不做 clamp）
 
 当 `fbr-effort = N`：

package/dist/llm/driver-v2/core.js

@@ -142,6 +142,52 @@ function resolveEffectiveOptimalMaxTokens(args) {
         criticalMaxTokensConfigured,
     };
 }
+function resolveFbrEffortDefaultForTool(member) {
+    const raw = member.fbr_effort;
+    if (typeof raw !== 'number' || !Number.isFinite(raw))
+        return 0;
+    if (!Number.isInteger(raw))
+        return 0;
+    if (raw < 0)
+        return 0;
+    if (raw > 100)
+        return 0;
+    return raw;
+}
+function createFreshBootsReasoningTool(args) {
+    const fbrDefault = args.fbrEffortDefault;
+    const fbrDefaultHint = fbrDefault > 0
+        ? `Runtime default for \`effort\` is current member \`fbr_effort=${fbrDefault}\` when omitted.`
+        : 'Runtime default for `effort` is current member `fbr_effort=0` (FBR disabled unless reconfigured).';
+    const codexAuthHint = args.providerApiType === 'codex'
+        ? ` Codex-auth note: function arguments are often emitted with all fields present; if user did not specify intensity, pass \`effort: ${fbrDefault}\` explicitly.`
+        : '';
+    return {
+        type: 'func',
+        name: 'freshBootsReasoning',
+        description: 'Start an FBR sideline dialog for tool-less fresh-boots reasoning. tellaskContent MUST stay neutral and fact-oriented (Goal/Facts/Constraints/Evidence[/Unknowns]); do not issue analysis directives (for example “from the following dimensions”, “analyze in steps 1..N”, or “N rounds per dimension”). ' +
+            fbrDefaultHint +
+            codexAuthHint,
+        parameters: {
+            type: 'object',
+            properties: {
+                tellaskContent: {
+                    type: 'string',
+                    description: 'Use a neutral factual body: Goal/Facts/Constraints/Evidence (optional Unknowns). Avoid dimension checklists and stepwise directives (e.g. “from the following dimensions/aspects”, “analyze in steps 1..N”, “N rounds per dimension”).',
+                },
+                effort: {
+                    type: 'integer',
+                    description: `Optional FBR intensity override (0..100 integer). Runtime maps intensity N to N serial FBR passes in one sideline window. When omitted, runtime defaults to current member fbr_effort=${fbrDefault}.`,
+                },
+            },
+            required: ['tellaskContent'],
+            additionalProperties: false,
+        },
+        call: async () => {
+            throw new Error('freshBootsReasoning is handled by driver-v2 tellask-special channel');
+        },
+    };
+}
 const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
     {
         type: 'func',
@@ -210,32 +256,20 @@ const TELLASK_SPECIAL_VIRTUAL_TOOLS = [
             throw new Error('askHuman is handled by driver-v2 tellask-special channel');
         },
     },
-    {
-        type: 'func',
-        name: 'freshBootsReasoning',
-        description: 'Start an FBR sideline dialog for tool-less fresh-boots reasoning. tellaskContent MUST stay neutral and fact-oriented (Goal/Facts/Constraints/Evidence[/Unknowns]); do not issue analysis directives (for example “from the following dimensions”, “analyze in steps 1..N”, or “N rounds per dimension”).',
-        parameters: {
-            type: 'object',
-            properties: {
-                tellaskContent: {
-                    type: 'string',
-                    description: 'Use a neutral factual body: Goal/Facts/Constraints/Evidence (optional Unknowns). Avoid dimension checklists and stepwise directives (e.g. “from the following dimensions/aspects”, “analyze in steps 1..N”, “N rounds per dimension”).',
-                },
-            },
-            required: ['tellaskContent'],
-            additionalProperties: false,
-        },
-        call: async () => {
-            throw new Error('freshBootsReasoning is handled by driver-v2 tellask-special channel');
-        },
-    },
 ];
 function mergeTellaskSpecialVirtualTools(baseTools, options) {
     const merged = [...baseTools];
     const seen = new Set(merged.map((tool) => tool.name));
+    const freshBootsReasoning = createFreshBootsReasoningTool({
+        fbrEffortDefault: options.fbrEffortDefault,
+        providerApiType: options.providerApiType,
+    });
     const specialTools = options.includeTellaskBack
-        ? TELLASK_SPECIAL_VIRTUAL_TOOLS
-        : TELLASK_SPECIAL_VIRTUAL_TOOLS.filter((tool) => tool.name !== 'tellaskBack');
+        ? [...TELLASK_SPECIAL_VIRTUAL_TOOLS, freshBootsReasoning]
+        : [
+            ...TELLASK_SPECIAL_VIRTUAL_TOOLS.filter((tool) => tool.name !== 'tellaskBack'),
+            freshBootsReasoning,
+        ];
     for (const virtualTool of specialTools) {
         if (seen.has(virtualTool.name)) {
             throw new Error(`driver-v2 tool invariant violation: function tool name '${virtualTool.name}' collides with tellask-special virtual tool`);
@@ -467,7 +501,10 @@ async function executeRoutedFunctionCalls(args) {
             case 'askHuman':
                 return { tellaskContent: call.tellaskContent };
             case 'freshBootsReasoning':
-                return { tellaskContent: call.tellaskContent };
+                return {
+                    tellaskContent: call.tellaskContent,
+                    ...(call.effort !== undefined ? { effort: call.effort } : {}),
+                };
             case 'tellask':
                 return {
                     targetAgentId: call.targetAgentId,
@@ -830,8 +867,13 @@ async function driveDialogStreamCoreV2(dlg, humanPrompt, driveOptions, callbacks
             }
             const canonicalFuncTools = agentTools.filter((t) => t.type === 'func');
             const isSubdialog = dlg.id.rootId !== dlg.id.selfId;
+            const fbrEffortDefault = resolveFbrEffortDefaultForTool(agent);
             const effectiveFuncTools = policy.allowFunctionCalls
-                ? mergeTellaskSpecialVirtualTools(canonicalFuncTools, { includeTellaskBack: isSubdialog })
+                ? mergeTellaskSpecialVirtualTools(canonicalFuncTools, {
+                    includeTellaskBack: isSubdialog,
+                    fbrEffortDefault,
+                    providerApiType: providerCfg.apiType,
+                })
                 : canonicalFuncTools;
             const projected = (0, tools_projection_1.projectFuncToolsForProvider)(providerCfg.apiType, effectiveFuncTools);
             const funcTools = projected.tools;

package/dist/llm/driver-v2/tellask-bridge.js

@@ -67,6 +67,25 @@ function readOptionalStringField(obj, field) {
     const trimmed = value.trim();
     return trimmed === '' ? null : trimmed;
 }
+function readOptionalEffortField(obj, field) {
+    const value = obj[field];
+    if (value === undefined) {
+        return { ok: true, value: undefined };
+    }
+    if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value)) {
+        return {
+            ok: false,
+            error: `field '${field}' must be an integer in [0, 100] when provided`,
+        };
+    }
+    if (value < 0 || value > 100) {
+        return {
+            ok: false,
+            error: `field '${field}' must be an integer in [0, 100] when provided`,
+        };
+    }
+    return { ok: true, value };
+}
 function readTargetAgentId(obj) {
     const target = readOptionalStringField(obj, 'targetAgentId') ??
         readOptionalStringField(obj, 'agentId') ??
@@ -125,12 +144,17 @@ function parseTellaskSpecialCall(call) {
             };
         }
         case 'freshBootsReasoning': {
+            const effort = readOptionalEffortField(args, 'effort');
+            if (!effort.ok) {
+                return effort;
+            }
             return {
                 ok: true,
                 value: {
                     callId: call.id,
                     callName: 'freshBootsReasoning',
                     tellaskContent: tellaskContent.value,
+                    effort: effort.value,
                 },
             };
         }
@@ -438,7 +462,33 @@ async function executeTellaskCall(dlg, agent, mentionList, body, callId, callbac
             return { toolOutputs, suspend: false, subdialogsCreated: [] };
         }
         if (isFreshBootsCall) {
-            const fbrEffort = resolveFbrEffort(member);
+            const memberFbrEffort = resolveFbrEffort(member);
+            if (memberFbrEffort < 1) {
+                const msg = (0, driver_messages_1.formatDomindsNoteFbrDisabled)((0, runtime_language_1.getWorkLanguage)());
+                toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
+                toolOutputs.push({
+                    type: 'tellask_result_msg',
+                    role: 'tool',
+                    responderId: 'dominds',
+                    mentionList: normalizedMentionList,
+                    tellaskContent: body,
+                    status: 'failed',
+                    callId,
+                    content: msg,
+                });
+                await dlg.receiveTeammateCallResult('dominds', callName, mentionList, body, msg, 'failed', callId);
+                dlg.clearCurrentCallId();
+                return { toolOutputs, suspend: false, subdialogsCreated: [] };
+            }
+            const override = options.fbrEffortOverride;
+            if (override !== undefined &&
+                (!Number.isFinite(override) ||
+                    !Number.isInteger(override) ||
+                    override < 0 ||
+                    override > 100)) {
+                throw new Error(`freshBootsReasoning invariant violation: effort override out of range [0,100] (got=${override})`);
+            }
+            const fbrEffort = override ?? memberFbrEffort;
             if (fbrEffort < 1) {
                 const msg = (0, driver_messages_1.formatDomindsNoteFbrDisabled)((0, runtime_language_1.getWorkLanguage)());
                 toolOutputs.push({ type: 'environment_msg', role: 'user', content: msg });
@@ -937,6 +987,7 @@ function toExecutableValidTellaskCall(call) {
                 callName: call.callName,
                 tellaskContent: call.tellaskContent,
                 callId: call.callId,
+                effort: call.effort,
             };
     }
 }
@@ -1067,6 +1118,7 @@ async function executeValidTellaskCalls(args) {
             parseResult,
             targetForError,
             q4hRemainingCallIds: call.q4hRemainingCallIds,
+            fbrEffortOverride: call.callName === 'freshBootsReasoning' ? call.effort : undefined,
         });
         results.push(result);
     }

package/dist/minds/system-prompt.js

@@ -44,13 +44,13 @@ function buildSystemPrompt(input) {
     const fbrPhaseContractZh = [
         '- FBR 必须按“发起 → 逐轮推理 → 上游回帖”三段执行：发起 `freshBootsReasoning` 只代表发起，不代表你已完成推理。',
         '- 发出 `freshBootsReasoning` 后，必须在该 FBR 子对话内按序走完整个 N 轮流程；只有最后一轮才会回帖给上游。',
-        '- 若 \\`fbr-effort = N\\`，等待该 FBR 子对话一次性完整回帖；收到全量回帖后完成提炼并据此做下游决策；不得基于未完成中间轮次提前定稿。',
+        '- 若 \\`fbr-effort = N\\`（力度 N，内部映射为 N 次串行推理），等待该 FBR 子对话一次性完整回帖；收到全量回帖后完成提炼并据此做下游决策；不得基于未完成中间轮次提前定稿。',
         '- 每一轮都应给出与此前不同的增量观点；每轮均不得复述前文结论。程序会把该 FBR 全量支线正文在最后一轮合并后回贴到上游。',
     ].join('\n');
     const fbrPhaseContractEn = [
         '- FBR MUST follow three phases: “initiate -> serial reasoning rounds -> upstream update”. Calling `freshBootsReasoning` means initiation only, not completed reasoning.',
         '- After calling `freshBootsReasoning`, run all required rounds in that single FBR sideline window; only the final round may post upstream.',
-        '- If \\`fbr-effort = N\\`, wait for the complete sideline response from the final round; after receiving the full reply, distill it before downstream action. Do not finalize based on partial rounds.',
+        '- If \\`fbr-effort = N\\` (intensity N, internally mapped to N serial passes), wait for the complete sideline response from the final pass; after receiving the full reply, distill it before downstream action. Do not finalize based on partial passes.',
         '- Every round must add a distinct incremental view. Every round, including the final one, must not repeat conclusions from earlier rounds. Runtime will relay the full accumulated FBR sideline output upstream in a single upstream-visible message.',
     ].join('\n');
     const teammatePhaseContractZh = [
@@ -111,7 +111,8 @@ function buildSystemPrompt(input) {
         '- FBR 禁止一切 tellask（包括 \`tellaskBack\` / \`tellask\` / \`tellaskSessionless\` / \`askHuman\`）。',
         '- 当用户明确要求“做一次 FBR/扪心自问”，对话主理人必须发起 \\`freshBootsReasoning\\`。',
         fbrScopeRuleZh,
-        '- FBR 的标准入口是 \\`freshBootsReasoning({ tellaskContent })\\`；禁止用 \\`tellask\\` / \\`tellaskSessionless\\` 对自己发起 self-target 诉请来替代。',
+        '- FBR 的标准入口是 \\`freshBootsReasoning({ tellaskContent, effort? })\\`；禁止用 \\`tellask\\` / \\`tellaskSessionless\\` 对自己发起 self-target 诉请来替代。',
+        '- 当用户自然语言里明确给了 FBR 力度（例如“做 fbr x6”/“做一次 6x fbr”），应把该力度映射到 \\`effort\\`（例如 \\`effort: 6\\`）；若未指定力度，按工具说明中的动态默认值传参。',
         '- 发起 FBR 时，\\`tellaskContent\\` 只写目标、事实、约束与证据，不要预设分析方向（例如固定问题清单/指定分析框架）。推理方向必须交由 FBR 支线自主拓展。',
         '- 发起前自检（强制）：若正文出现“请从以下维度/按以下方面/按步骤 1..N 分析”等预设提纲语句，必须先改写再调用 \\`freshBootsReasoning\\`；否则视为违规调用。',
         '- 发起正文推荐模板（强制遵循语义）：\\`目标\\` / \\`事实\\` / \\`约束\\` / \\`证据\\`（可选 \\`未知项\\`）。正文应是事实陈述，不是对 FBR 支线下达“按维度/按步骤分析”的命令。',
@@ -127,7 +128,8 @@ function buildSystemPrompt(input) {
         '- FBR forbids all tellask calls (including \`tellaskBack\` / \`tellask\` / \`tellaskSessionless\` / \`askHuman\`).',
         '- When the user explicitly requests “do an FBR / fresh boots reasoning”, the Dialog Responder must call `freshBootsReasoning`.',
         fbrScopeRuleEn,
-        '- The standard FBR entry is \\`freshBootsReasoning({ tellaskContent })\\`; do not emulate FBR via self-targeted \\`tellask\\` / \\`tellaskSessionless\\`.',
+        '- The standard FBR entry is \\`freshBootsReasoning({ tellaskContent, effort? })\\`; do not emulate FBR via self-targeted \\`tellask\\` / \\`tellaskSessionless\\`.',
+        '- When the user gives an explicit FBR intensity in natural language (for example “do fbr x6” / “run one 6x fbr”), map it to \\`effort\\` (for example \\`effort: 6\\`); when the user does not specify intensity, pass the dynamic default described in the tool documentation.',
         '- When initiating FBR, keep \\`tellaskContent\\` to goals, facts, constraints, and evidence only; do not predefine analysis directions (for example fixed question checklists or prescribed frameworks). Reasoning directions must be expanded autonomously by the FBR sideline.',
         '- Pre-call self-check (mandatory): if the body contains scaffolded directives such as “from the following dimensions/aspects” or stepwise templates (“analyze in steps 1..N”), rewrite first, then call \\`freshBootsReasoning\\`; otherwise the call is a protocol violation.',
         '- Recommended body template (semantic MUST): \\`Goal\\` / \\`Facts\\` / \\`Constraints\\` / \\`Evidence\\` (optional \\`Unknowns\\`). The body should present neutral facts, not command the FBR sideline to analyze by fixed dimensions or steps.',
@@ -142,14 +144,14 @@ function buildSystemPrompt(input) {
         '- \\`tellask\\`：用于可恢复的长线诉请（必须提供 \\`targetAgentId\\` / \\`sessionSlug\\` / \\`tellaskContent\\`）。',
         '- \\`tellaskSessionless\\`：用于一次性诉请（必须提供 \\`targetAgentId\\` / \\`tellaskContent\\`）。',
         '- \\`askHuman\\`：用于 Q4H（向人类请求必要澄清/决策/授权/缺失输入）。',
-        '- \\`freshBootsReasoning\\`：用于发起扪心自问（FBR）支线（仅需 \\`tellaskContent\\`）。',
+        '- \\`freshBootsReasoning\\`：用于发起扪心自问（FBR）支线（\\`tellaskContent\\` 必填，\\`effort\\` 可选）。',
     ].join('\n');
     const tellaskInteractionRulesEn = [
         '- \\`tellaskBack\\`: ask back upstream from a sideline dialog only.',
         '- \\`tellask\\`: resumable tellask (requires \\`targetAgentId\\` / \\`sessionSlug\\` / \\`tellaskContent\\`).',
         '- \\`tellaskSessionless\\`: one-shot tellask (requires \\`targetAgentId\\` / \\`tellaskContent\\`).',
         '- \\`askHuman\\`: Q4H for necessary clarification/decision/authorization/missing input.',
-        '- \\`freshBootsReasoning\\`: starts an FBR sideline dialog (requires \\`tellaskContent\\`).',
+        '- \\`freshBootsReasoning\\`: starts an FBR sideline dialog (requires \\`tellaskContent\\`, optional \\`effort\\`).',
     ].join('\n');
     const functionToolRulesZh = [
         '- 回答必须基于可观测事实；为获取事实优先使用可用工具，缺乏观测事实时明确说明并请求/补充获取，不得臆测。',

package/dist/shared/i18n/driver-messages.js

@@ -211,11 +211,11 @@ function formatAgentFacingContextHealthV3RemediationGuide(language, args) {
 function formatDomindsNoteDirectSelfCall(language) {
     if (language === 'zh') {
         return ('错误：不允许通过 `tellask` / `tellaskSessionless` 对当前 agent 发起自诉请。\n' +
-            '- 若你要发起扪心自问（FBR），请使用 `freshBootsReasoning({ tellaskContent })`。\n' +
+            '- 若你要发起扪心自问（FBR），请使用 `freshBootsReasoning({ tellaskContent, effort? })`。\n' +
             '- `tellask` / `tellaskSessionless` 仅用于队友诉请（targetAgentId 必须是队友 id）。');
     }
     return ('Error: self-targeted calls via `tellask` / `tellaskSessionless` are not allowed.\n' +
-        '- For FBR, use `freshBootsReasoning({ tellaskContent })`.\n' +
+        '- For FBR, use `freshBootsReasoning({ tellaskContent, effort? })`.\n' +
         '- `tellask` / `tellaskSessionless` are teammate-only (targetAgentId must be a teammate id).');
 }
 function formatDomindsNoteFbrDisabled(language) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "DevOps Mindsets — Sustainable Agentic Product Lifecycle",
   "type": "commonjs",
   "private": false,
@@ -45,9 +45,10 @@
     "url": "https://github.com/longrun-ai/dominds/issues"
   },
   "homepage": "https://github.com/longrun-ai/dominds#readme",
-  "packageManager": "pnpm@10.28.2",
+  "packageManager": "pnpm@10.30.2",
   "engines": {
-    "node": ">=22 <23"
+    "node": ">=22 <23",
+    "pnpm": ">=10.30.2 <11"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.67.0",