dominds 0.6.2 → 0.6.4

package/dist/cli/read.js

@@ -10,15 +10,24 @@
  *   --no-hints           Don't show hints
  *   --only-prompt        Show only system prompt
  *   --only-mem           Show only memories
+ *   --audit              Run built-in prompt audit checks
+ *   --fail-on-audit-warning  Exit non-zero when audit emits warnings
+ *   --find <pattern>     Find case-insensitive text in rendered output
  *   --help               Show help
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
+const promises_1 = require("fs/promises");
+const config_1 = require("../mcp/config");
 const load_1 = require("../minds/load");
+const team_1 = require("../team");
+const registry_1 = require("../tools/registry");
 function printUsage() {
-    console.log('Usage: dominds read [<member-id>] [--no-hints] [--only-prompt|--only-mem]');
+    console.log('Usage: dominds read [<member-id>] [--no-hints] [--only-prompt|--only-mem] [--audit] [--find <pattern>]');
     console.log('');
     console.log('Print agent system prompt and memories with filtering flags.');
+    console.log('`--audit` also includes static toolset checks (registry vs `.minds/mcp.yaml` declarations).');
+    console.log('When <member-id> is omitted, reads all visible team members.');
     console.log('');
     console.log("Note: rtws (runtime workspace) directory is `process.cwd()`. Use 'dominds -C <dir> read' to run in another rtws.");
     console.log('');
@@ -27,12 +36,297 @@ function printUsage() {
     console.log('  dominds read developer          # Read specific member');
     console.log('  dominds read --only-prompt      # Show only system prompts');
     console.log('  dominds read --only-mem         # Show only memories');
+    console.log('  dominds read --only-prompt --audit');
+    console.log('  dominds read ux --only-prompt --find "pending Tellask"');
+    console.log('  dominds read --only-prompt --audit --fail-on-audit-warning');
 }
-async function main() {
-    const args = process.argv.slice(2);
+function normalizeForDuplicateScan(line) {
+    return line
+        .trim()
+        .replace(/^[-*]\s+/, '')
+        .replace(/[`*_]/g, '')
+        .replace(/\s+/g, ' ')
+        .toLowerCase();
+}
+function buildPromptAudit(systemPrompt) {
+    const checks = [
+        {
+            id: 'collaboration_protocol',
+            label: 'Has collaboration protocol section',
+            pass: /## (Collaboration Protocol|协作协议)/.test(systemPrompt),
+        },
+        {
+            id: 'response_closes_round',
+            label: 'Has "response closes call round" rule',
+            pass: /response closes that call round/.test(systemPrompt) ||
+                /收到回贴即表示该轮调用已结束/.test(systemPrompt),
+        },
+        {
+            id: 'pending_wait_guard',
+            label: 'Has pending tellask wait guard',
+            pass: /pending Tellask|pending tellask/.test(systemPrompt) ||
+                /存在明确 pending tellask/.test(systemPrompt),
+        },
+        {
+            id: 'relay_ban',
+            label: 'Has no-human-relay rule',
+            pass: /relay for executable teammate work/.test(systemPrompt) || /转发员/.test(systemPrompt),
+        },
+        {
+            id: 'tellask_function_boundary',
+            label: 'Has tellask vs function-calling boundary',
+            pass: /native function-calling/.test(systemPrompt) &&
+                (/is only for tellasking teammates\/@self\/@human/.test(systemPrompt) ||
+                    /仅用于诉请队友\/@self\/@human/.test(systemPrompt)),
+        },
+        {
+            id: 'tellask_line_grammar',
+            label: 'Has tellask line-prefix grammar',
+            pass: /line-prefix grammar/.test(systemPrompt) || /逐行前缀语法/.test(systemPrompt),
+        },
+        {
+            id: 'fbr_phase_contract',
+            label: 'Has FBR phase contract',
+            pass: /FBR phase contract|FBR 阶段协议/.test(systemPrompt),
+        },
+        {
+            id: 'taskdoc_encapsulation',
+            label: 'Has Taskdoc encapsulation section',
+            pass: /Taskdoc encapsulation & access restrictions/.test(systemPrompt) ||
+                /差遣牒.*封装/.test(systemPrompt),
+        },
+    ];
+    const hasDomindsRuntime = /Dominds runtime|genuine Codex CLI/.test(systemPrompt);
+    const hasCodexHostIdentity = /You are GPT-5\.2 running in the Codex CLI/.test(systemPrompt) ||
+        /^You are Codex CLI\.$/m.test(systemPrompt);
+    const toolSectionMarkers = ['\n## Intrinsic Tools\n', '\n## 内置工具\n'];
+    let duplicateScope = systemPrompt;
+    for (const marker of toolSectionMarkers) {
+        const idx = duplicateScope.indexOf(marker);
+        if (idx >= 0) {
+            duplicateScope = duplicateScope.slice(0, idx);
+            break;
+        }
+    }
+    const lineCounts = new Map();
+    const representative = new Map();
+    for (const rawLine of duplicateScope.split('\n')) {
+        const line = rawLine.trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        const normalized = normalizeForDuplicateScan(line);
+        if (normalized.length < 24)
+            continue;
+        lineCounts.set(normalized, (lineCounts.get(normalized) ?? 0) + 1);
+        if (!representative.has(normalized))
+            representative.set(normalized, line);
+    }
+    const duplicates = Array.from(lineCounts.entries())
+        .filter(([, count]) => count > 1)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 12)
+        .map(([normalized, count]) => ({
+        line: representative.get(normalized) ?? normalized,
+        count,
+    }));
+    const warnings = [];
+    for (const check of checks) {
+        if (!check.pass)
+            warnings.push(`Missing: ${check.label}`);
+    }
+    if (hasDomindsRuntime && hasCodexHostIdentity) {
+        warnings.push('Potential host identity conflict: both Dominds runtime and Codex host identity text found.');
+    }
+    if (duplicates.length > 0) {
+        warnings.push(`Detected ${duplicates.length} repeated prompt lines (top duplicates shown).`);
+    }
+    return { checks, duplicates, warnings };
+}
+function printPromptAudit(report) {
+    process.stdout.write('\n## Prompt Audit\n');
+    for (const check of report.checks) {
+        const tag = check.pass ? 'OK' : 'MISS';
+        process.stdout.write(`- [${tag}] ${check.label}\n`);
+    }
+    if (report.duplicates.length > 0) {
+        process.stdout.write('- Duplicate Lines (top):\n');
+        for (const d of report.duplicates) {
+            process.stdout.write(`  - x${d.count}: ${d.line}\n`);
+        }
+    }
+    else {
+        process.stdout.write('- Duplicate Lines: none\n');
+    }
+    if (report.warnings.length > 0) {
+        process.stdout.write('- Warnings:\n');
+        for (const warning of report.warnings) {
+            process.stdout.write(`  - ${warning}\n`);
+        }
+    }
+    else {
+        process.stdout.write('- Warnings: none\n');
+    }
+}
+function listExplicitToolsets(member) {
+    if (!member.toolsets)
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const entry of member.toolsets) {
+        if (entry === '*' || entry.startsWith('!'))
+            continue;
+        if (seen.has(entry))
+            continue;
+        seen.add(entry);
+        out.push(entry);
+    }
+    return out;
+}
+async function readMcpDeclaredToolsets() {
+    const mcpPath = '.minds/mcp.yaml';
+    let raw;
+    try {
+        raw = await (0, promises_1.readFile)(mcpPath, 'utf8');
+    }
+    catch (err) {
+        if (typeof err === 'object' &&
+            err !== null &&
+            'code' in err &&
+            err.code === 'ENOENT') {
+            return { kind: 'missing' };
+        }
+        return { kind: 'invalid', errorText: err instanceof Error ? err.message : String(err) };
+    }
+    const parsed = (0, config_1.parseMcpYaml)(raw);
+    if (!parsed.ok) {
+        return { kind: 'invalid', errorText: parsed.errorText };
+    }
+    return {
+        kind: 'loaded',
+        declaredServerIds: new Set(parsed.serverIdsInYamlOrder),
+        invalidServerIds: new Set(parsed.invalidServers.map((s) => s.serverId)),
+    };
+}
+function buildToolsetAuditReport(params) {
+    const registeredToolsets = new Set(Object.keys((0, registry_1.listToolsets)()));
+    const byMember = [];
+    const warnings = [];
+    for (const memberId of params.targetMemberIds) {
+        const member = params.team.getMember(memberId);
+        if (!member)
+            continue;
+        const explicitToolsets = listExplicitToolsets(member);
+        const items = [];
+        for (const toolsetName of explicitToolsets) {
+            if (registeredToolsets.has(toolsetName)) {
+                items.push({ toolsetName, status: 'registered' });
+                continue;
+            }
+            if (params.mcp.kind === 'loaded' && params.mcp.declaredServerIds.has(toolsetName)) {
+                if (params.mcp.invalidServerIds.has(toolsetName)) {
+                    items.push({ toolsetName, status: 'mcp_declared_invalid' });
+                    warnings.push(`@${member.id}: toolset '${toolsetName}' is declared in mcp.yaml but server config is invalid.`);
+                }
+                else {
+                    items.push({ toolsetName, status: 'mcp_declared_unloaded' });
+                }
+                continue;
+            }
+            items.push({ toolsetName, status: 'missing' });
+            warnings.push(`@${member.id}: toolset '${toolsetName}' is neither registered nor declared in mcp.yaml.`);
+        }
+        byMember.push({ memberId: member.id, memberName: member.name, items });
+    }
+    if (params.mcp.kind === 'invalid') {
+        warnings.push(`Invalid .minds/mcp.yaml; cannot reliably classify unresolved MCP toolsets: ${params.mcp.errorText}`);
+    }
+    return {
+        mcp: params.mcp,
+        byMember,
+        warnings,
+    };
+}
+function printToolsetAudit(report) {
+    process.stdout.write('\n## Toolset Audit\n');
+    if (report.mcp.kind === 'missing') {
+        process.stdout.write('- MCP config: missing (`.minds/mcp.yaml` not found)\n');
+    }
+    else if (report.mcp.kind === 'invalid') {
+        process.stdout.write('- MCP config: invalid (`.minds/mcp.yaml` parse/read failed)\n');
+    }
+    else {
+        process.stdout.write(`- MCP config: loaded (declared servers: ${report.mcp.declaredServerIds.size}, invalid server configs: ${report.mcp.invalidServerIds.size})\n`);
+    }
+    if (report.byMember.length === 0) {
+        process.stdout.write('- Members: none\n');
+    }
+    else {
+        for (const memberReport of report.byMember) {
+            process.stdout.write(`- @${memberReport.memberId} (${memberReport.memberName}):\n`);
+            if (memberReport.items.length === 0) {
+                process.stdout.write('  - no explicit toolset declarations\n');
+                continue;
+            }
+            for (const item of memberReport.items) {
+                const label = item.status === 'registered'
+                    ? 'OK'
+                    : item.status === 'mcp_declared_unloaded'
+                        ? 'DEFERRED'
+                        : item.status === 'mcp_declared_invalid'
+                            ? 'INVALID'
+                            : 'MISS';
+                process.stdout.write(`  - [${label}] ${item.toolsetName}\n`);
+            }
+        }
+    }
+    if (report.warnings.length > 0) {
+        process.stdout.write('- Warnings:\n');
+        for (const warning of report.warnings) {
+            process.stdout.write(`  - ${warning}\n`);
+        }
+    }
+    else {
+        process.stdout.write('- Warnings: none\n');
+    }
+}
+function collectFindMatches(text, pattern) {
+    const normalizedPattern = pattern.toLowerCase();
+    const lines = text.split('\n');
+    const matches = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.toLowerCase().includes(normalizedPattern)) {
+            matches.push({ line: i + 1, text: line });
+            if (matches.length >= 60)
+                break;
+        }
+    }
+    return matches;
+}
+function printFindResults(pattern, blocks) {
+    process.stdout.write(`\n## Find: "${pattern}"\n`);
+    let total = 0;
+    for (const block of blocks) {
+        const matches = collectFindMatches(block.text, pattern);
+        if (matches.length === 0)
+            continue;
+        total += matches.length;
+        process.stdout.write(`- ${block.name} (${matches.length}):\n`);
+        for (const match of matches) {
+            process.stdout.write(`  - L${match.line}: ${match.text}\n`);
+        }
+    }
+    if (total === 0) {
+        process.stdout.write('- no matches\n');
+    }
+}
+function parseArgs(args) {
     let memberId;
     let onlyPrompt = false;
     let onlyMem = false;
+    let audit = false;
+    let failOnAuditWarning = false;
+    const findPatterns = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg === '--only-prompt') {
@@ -41,6 +335,20 @@ async function main() {
         else if (arg === '--only-mem') {
             onlyMem = true;
         }
+        else if (arg === '--audit') {
+            audit = true;
+        }
+        else if (arg === '--fail-on-audit-warning') {
+            failOnAuditWarning = true;
+        }
+        else if (arg === '--find') {
+            const next = args[i + 1];
+            if (!next || next.startsWith('-')) {
+                throw new Error("Option '--find' requires a non-empty pattern argument.");
+            }
+            findPatterns.push(next);
+            i++;
+        }
         else if (arg === '--no-hints') {
             // Deprecated, but keep for compatibility
             console.warn('Warning: --no-hints is deprecated, use --only-prompt or --only-mem instead');
@@ -53,23 +361,109 @@ async function main() {
             memberId = arg;
         }
         else {
-            console.error(`Error: unexpected argument '${arg}'`);
-            printUsage();
-            process.exit(1);
+            throw new Error(`Unexpected argument '${arg}'.`);
         }
     }
+    if (onlyPrompt && onlyMem) {
+        throw new Error("Options '--only-prompt' and '--only-mem' are mutually exclusive.");
+    }
+    return {
+        memberId,
+        onlyPrompt,
+        onlyMem,
+        audit,
+        failOnAuditWarning,
+        findPatterns,
+    };
+}
+function resolveTargetMemberIds(team, memberId) {
+    if (memberId)
+        return [memberId];
+    const visibleIds = Object.values(team.members)
+        .filter((m) => m.hidden !== true)
+        .map((m) => m.id)
+        .sort((a, b) => a.localeCompare(b));
+    if (visibleIds.length > 0)
+        return visibleIds;
+    const fallback = team.getDefaultResponder();
+    if (!fallback)
+        throw new Error('No team members found.');
+    return [fallback.id];
+}
+async function main() {
+    const args = process.argv.slice(2);
+    let parsed;
+    try {
+        parsed = parseArgs(args);
+    }
+    catch (err) {
+        console.error('Error:', err instanceof Error ? err.message : String(err));
+        printUsage();
+        process.exit(1);
+        return;
+    }
     try {
-        const { systemPrompt, memories } = await (0, load_1.loadAgentMinds)(memberId);
-        if (!onlyMem) {
-            process.stdout.write(systemPrompt.trim() + '\n');
-        }
-        if (!onlyPrompt) {
+        const team = await team_1.Team.load();
+        const targetMemberIds = resolveTargetMemberIds(team, parsed.memberId);
+        const isMultiMemberRun = targetMemberIds.length > 1;
+        const toolsetAudit = parsed.audit
+            ? buildToolsetAuditReport({
+                team,
+                targetMemberIds,
+                mcp: await readMcpDeclaredToolsets(),
+            })
+            : undefined;
+        let auditWarningCount = 0;
+        for (let idx = 0; idx < targetMemberIds.length; idx++) {
+            const targetMemberId = targetMemberIds[idx];
+            const { agent, systemPrompt, memories } = await (0, load_1.loadAgentMinds)(targetMemberId, undefined, {
+                missingToolsetPolicy: parsed.audit ? 'silent' : 'warn',
+            });
+            const renderedMemoryBlocks = [];
             for (const mem of memories) {
                 if ('content' in mem && typeof mem.content === 'string' && mem.content.trim()) {
-                    process.stdout.write('\n' + mem.content.trim() + '\n');
+                    renderedMemoryBlocks.push(mem.content.trim());
+                }
+            }
+            if (isMultiMemberRun) {
+                const sep = idx === 0 ? '' : '\n\n';
+                process.stdout.write(`${sep}===== @${agent.id} (${agent.name}) =====\n`);
+            }
+            if (!parsed.onlyMem) {
+                process.stdout.write(systemPrompt.trim() + '\n');
+            }
+            if (!parsed.onlyPrompt) {
+                for (const content of renderedMemoryBlocks) {
+                    process.stdout.write('\n' + content + '\n');
+                }
+            }
+            if (parsed.audit) {
+                const report = buildPromptAudit(systemPrompt);
+                printPromptAudit(report);
+                auditWarningCount += report.warnings.length;
+            }
+            if (parsed.findPatterns.length > 0) {
+                const blocks = [];
+                if (!parsed.onlyMem) {
+                    blocks.push({ name: `@${agent.id}/system_prompt`, text: systemPrompt });
+                }
+                if (!parsed.onlyPrompt) {
+                    for (let i = 0; i < renderedMemoryBlocks.length; i++) {
+                        blocks.push({ name: `@${agent.id}/memory_${i + 1}`, text: renderedMemoryBlocks[i] });
+                    }
+                }
+                for (const pattern of parsed.findPatterns) {
+                    printFindResults(pattern, blocks);
                 }
             }
         }
+        if (parsed.audit && toolsetAudit) {
+            printToolsetAudit(toolsetAudit);
+            auditWarningCount += toolsetAudit.warnings.length;
+        }
+        if (parsed.failOnAuditWarning && auditWarningCount > 0) {
+            process.exit(2);
+        }
     }
     catch (err) {
         console.error('Error loading agent minds:', err instanceof Error ? err.message : String(err));

package/dist/dialog.js

@@ -628,6 +628,9 @@ class Dialog {
     async funcCallRequested(funcId, funcName, argumentsStr) {
         await this.dlgStore.funcCallRequested(this, funcId, funcName, argumentsStr);
     }
+    async webSearchCall(payload) {
+        await this.dlgStore.webSearchCall(this, payload);
+    }
     // Tellask call events (streaming mode - `!?@...` blocks)
     async callingStart(validation) {
         await this.dlgStore.callingStart(this, validation);
@@ -1014,6 +1017,7 @@ class DialogStore {
     async callingFinish(_dialog, _callId) { }
     // Function call event (non-streaming mode - single event)
     async funcCallRequested(_dialog, _funcId, _funcName, _argumentsStr) { }
+    async webSearchCall(_dialog, _payload) { }
     /**
      * Load current course number from persisted metadata
      * This method should be implemented by subclasses to read from storage

package/dist/docs/design.md

@@ -555,6 +555,7 @@ dominds dialog start --taskdoc-path tasks/auth-system.tsk
 - rtws hard rules:
   - `*.tsk/**` is encapsulated Taskdoc state and is hard-denied for all general file tools.
   - `.minds/**` is reserved rtws state (team config/memory/assets) and is hard-denied for all general file tools; manage it via dedicated tools like `team-mgmt`.
+  - DevOps context: ad-hoc temp scripts are a taboo. If a tool script is needed, align with teammates and the human, then formalize it in the rtws before use.
 
 **Collaboration Example**:
 

package/dist/docs/design.zh.md

@@ -553,6 +553,7 @@ dominds dialog start --taskdoc-path tasks/auth-system.tsk
 - rtws 硬性规则：
   - `*.tsk/**` 是封装的差遣牒状态，所有通用文件工具都硬性拒绝。
   - `.minds/**` 是保留的 rtws 状态（团队配置/内存/资产），所有通用文件工具都硬性拒绝；通过 `team-mgmt` 等专用工具进行管理。
+  - DevOps 场景：忌讳临时脚本。如需工具脚本，应与队友和人类对齐后，在 rtws 中正式设计/命名/规范化再使用。
 
 **协作示例：**
 

package/dist/docs/dialog-system.md

@@ -164,8 +164,9 @@ flowchart TD
 - Uses `subdialog.supdialog` reference (no registry lookup)
 - No registration - supdialog relationship is inherent
 - Supdialog is always the direct parent in the hierarchy
-- `!?@tellasker` is the canonical Type A syntax: it always routes to the tellasker (the dialog that issued the current Tellask)
-  is identical to the subdialog's `agentId` (common for Fresh Boots Reasoning self-subdialogs).
+- `!?@tellasker` is the canonical Type A syntax: it always routes to the tellasker (the dialog that issued the current Tellask).
+- This matters especially when the supdialog’s `agentId` is identical to the subdialog’s `agentId` (common when a sideline
+  is created via `!?@self`), where an explicit `!?@<supdialogAgentId>` is easier to get wrong by accident.
 - The explicit `!?@<supdialogAgentId>` form is accepted as a semantic fallback for backwards compatibility, but is more
   error-prone in FBR/self-subdialog cases.
 
@@ -193,6 +194,7 @@ Result:
 - `!?@self` is an explicit “same persona” call that targets the **current dialog’s agentId** (not a separate teammate).
 - This is an **unambiguous** syntax for self-tellasks and helps avoid accidental `@teammate`→`@teammate` self-tellasks caused by
   echoing/quoting prior call headlines.
+- In Dominds, `!?@self` Tellasks are treated as FBR and are driven under a stricter, tool-less policy; see [`fbr.md`](./fbr.md).
 - **FBR itself should be common**, but the `!tellaskSession`-addressed variant should be rare. Prefer `!?@self` (TYPE C, transient)
   for most FBR usage. Use `!?@self !tellaskSession ...` only when you explicitly want a resumable, long-lived “fresh boots session”
   for a multi-step sub-problem.
@@ -269,14 +271,17 @@ Result (second call):
 
 **Fresh Boots Reasoning (FBR) self-tellask syntax (default; most common)**: `!?@self`
 
-- `!?@self` targets the current dialog’s agentId and creates a **new ephemeral subdialog** with the same persona/config.
+- `!?@self` targets the current dialog’s agentId and creates a **new ephemeral subdialog** routed to the same agentId.
+- The sideline dialog created by `!?@self` is FBR and is driven under a stricter, tool-less policy; see [`fbr.md`](./fbr.md).
 - Use this for most Fresh Boots Reasoning sessions: isolate a single sub-problem, produce an answer, and return.
 
 **Behavior**:
 
 1. Current dialog **suspends**
 2. Create **NEW subdialog** with the specified agentId
-3. Drive the new subdialog (it is FULL-FLEDGED - can make supcalls, teammate Tellasks, function tool calls)
+3. Drive the new subdialog:
+   - For general Type C, the subdialog is full-fledged (supcalls, teammate Tellasks, tools per config).
+   - For `!?@self`, runtime applies the FBR tool-less policy (no tools; restricted Tellasks).
 4. Subdialog response flows back to parent
 5. Parent **resumes** with subdialog's response
 
@@ -284,7 +289,7 @@ Result (second call):
 
 - **No registry lookup** - always creates a new subdialog
 - **Not registered** - no persistence across Tellasks
-- The subdialog itself is fully capable (can make supcalls, teammate Tellasks, function tool calls)
+- The subdialog itself is fully capable **except** for `!?@self` FBR, which is tool-less and Tellask-restricted (see `fbr.md`).
 - Only difference from TYPE B: no registry lookup/resume capability
 - Used for one-off, independent tasks
 
@@ -1100,7 +1105,7 @@ sequenceDiagram
   Driver-->>Sub: resume subdialog with response in context
 ```
 
-#### TYPE B: Registered Subdialog Tellask (`Tellask Session`) (`!?@agentId !tellaskSession tellaskSession`, or `!?@self !tellaskSession tellaskSession`)
+#### TYPE B: Registered Subdialog Tellask (`Tellask Session`) (`!?@agentId !tellaskSession tellaskSession`; `!?@self !tellaskSession ...` is FBR tool-less)
 
 ```mermaid
 sequenceDiagram
@@ -1125,7 +1130,7 @@ sequenceDiagram
   end
 ```
 
-#### TYPE C: Transient Subdialog Tellask (`Fresh Tellask`) (`!?@agentId`, or `!?@self`)
+#### TYPE C: Transient Subdialog Tellask (`Fresh Tellask`) (`!?@agentId`; `!?@self` is FBR tool-less)
 
 ```mermaid
 sequenceDiagram

package/dist/docs/dialog-system.zh.md

@@ -189,6 +189,7 @@ LLM 发出：!?@orchestrator 我应该如何处理数据库迁移？
 
 - `!?@self` 是一个显式的"相同角色"调用，指向**当前对话的 agentId**（不是单独队友）。
 - 这是自调用的**明确**语法，有助于避免因回声/引用先前调用标题而导致的意外 `@teammate`→`@teammate` 自调用。
+- 注意：在 Dominds 中，`!?@self` 会触发扪心自问（FBR）机制，并以更严格的“无工具”策略驱动；详见 [`fbr.zh.md`](./fbr.zh.md)。
 - **FBR 本身应该很常见**，但使用 `!tellaskSession` 寻址的变体应该很罕见。对于大多数 FBR 使用，首选 `!?@self`（TYPE C，瞬态）。仅当你明确想要一个可恢复的、长期存在的"初心会话"用于多步骤子问题时，才使用 `!?@self !tellaskSession ...`。
 
 **Tellask 会话键模式**：`<tellaskSession>` 使用与 `<mention-id>` 相同的标识符模式：`[a-zA-Z][a-zA-Z0-9_-]*`。解析在空白或标点处停止；任何尾随的标题文本在 tellaskSession 解析时被忽略。
@@ -261,14 +262,17 @@ LLM 再次发出：!?@researcher !tellaskSession market-analysis
 
 **扪心自问 (FBR) 自调用语法（默认；最常见）**：`!?@self`
 
-- `!?@self` 指向当前对话的 agentId，并创建一个具有相同角色/配置的**新的临时子对话**。
+- `!?@self` 指向当前对话的 agentId，并创建一条路由到同一 agentId 的**新的临时子对话**。
+- 由 `!?@self` 创建的支线对话属于 FBR，并以更严格的“无工具”策略驱动；详见 [`fbr.zh.md`](./fbr.zh.md)。
 - 对于大多数扪心自问 会话使用此方式：隔离单个子问题，产生答案，然后返回。
 
 **行为**：
 
 1. 当前对话**挂起**
 2. 使用指定的 agentId 创建**新的子对话**
-3. 驱动新的子对话（它是完全成熟的 - 可以进行上位调用、队友 Tellask、工具调用）
+3. 驱动新的子对话：
+   - 一般 TYPE C 子对话是“完整能力”的（可上位调用、队友诉请、按配置使用工具）。
+   - `!?@self` 属于 FBR 特例：无工具、诉请受限（见 `fbr.zh.md`）。
 4. 子对话的响应流回父级
 5. 父级**恢复**，子对话的响应在上下文中
 
@@ -276,7 +280,7 @@ LLM 再次发出：!?@researcher !tellaskSession market-analysis
 
 - **无注册表查找** - 总是创建新的子对话
 - **不注册** - 在 Tellask 之间不持久化
-- 子对话本身是完全 capable 的（可以进行上位调用、队友 Tellask、工具调用）
+- 子对话本身一般是“完整能力”的；但 `!?@self` FBR 是特例：无工具且诉请受限（见 `fbr.zh.md`）。
 - 与 TYPE B 的唯一区别：无注册表查找/恢复能力
 - 用于一次性的、独立的任务
 

package/dist/docs/dominds-agent-priming.md

@@ -40,6 +40,7 @@ Related docs:
 
 - Establish immediate trust that Tellask/return/persistence are real.
 - Run a real `!?@self` FBR loop at dialog creation.
+- Build muscle memory for the timing contract: initiate FBR, wait for feedback, then synthesize/decide.
 - Make distillation itself part of the “felt” experience (dedupe/reconcile/extract-the-best).
 - Keep the procedure safe, small, and deterministic (default command: `uname -a`).
 - Persist and display the interaction so it is credible from multiple angles (backend record + frontend transcript).
@@ -109,9 +110,15 @@ Optional parallel drafts:
 - If `fbr_effort` is `0`, skip FBR.
 - If `fbr_effort` is greater than `100`, the runtime errors out and stops priming (invalid config).
 
+Phase boundary (critical):
+
+- `!?@self` is the **initiation action**, not completed decision-making.
+- Mainline must enter a wait phase until feedback from that FBR run returns.
+- If `fbr_effort = N`, mainline must wait for all N drafts before distillation; do not finalize from partial drafts.
+
 ### 4) Distill into an “Agent Priming” note
 
-The main agent then writes a short, user-visible **Agent Priming** note via a **normal generation** in the mainline
+After confirming feedback from that FBR run has been collected, the main agent writes a short, user-visible **Agent Priming** note via a **normal generation** in the mainline
 dialog. It should be explicitly distilled (dedupe/reconcile/extract-the-best) rather than repeating each draft.
 
 Implementation constraint (matches runtime behavior):
@@ -120,6 +127,8 @@ Implementation constraint (matches runtime behavior):
 - The runtime may use a non-persisted **internal prompt** to anchor “this generation is distillation”.
 - The runtime may also include the shell snapshot and FBR drafts as “evidence” inside that internal prompt (for this
   drive only, not persisted), so distillation does not depend on any queue timing/concurrency details.
+- During the Agent Priming lifecycle (from prelude start until the priming note is produced), runtime must suppress
+  diligence-push injections; restore normal diligence behavior only after priming completes.
 
 Implementation note (internal prompt):
 

package/dist/docs/dominds-agent-priming.zh.md

@@ -29,6 +29,7 @@ Dominds 的诉请（Tellask，`!?@...`）与扪心自问（FBR，`!?@self`）并
 
 - 在对话一开始就建立“诉请/回传/持久化都是真的”的信任。
 - 在对话一开始就跑通一次 `!?@self` 的 FBR 回路。
+- 把“发起 FBR 后先等待回贴，再做综合决策”的时序固化为肌肉记忆。
 - 把多份 FBR 草稿做一次**综合提炼**，把“取精华、去糟粕”的动作也变成体感的一部分。
 - 过程足够小、可控、低风险（默认只执行 `uname -a`）。
 - 记录从多角度都高度拟真：后端存档 + 前端可见的对话转录。
@@ -95,15 +96,22 @@ Dominds 的诉请（Tellask，`!?@...`）与扪心自问（FBR，`!?@self`）并
 - 若 `fbr_effort` 为 `0`，则跳过 FBR。
 - 若 `fbr_effort` 大于 `100`，运行时会报错并终止启动流程（配置错误）。
 
+阶段边界（关键）：
+
+- `!?@self` 只是**发起动作**，不是“已完成决策”。
+- 主线对话必须先进入等待态，直到该次 FBR 的回贴返回。
+- 若 `fbr_effort = N`，主线必须等待全部 N 条回贴后再进入综合提炼；不得基于部分草稿提前定稿。
+
 ### 4）综合提炼成“智能体启动（Priming）”笔记
 
-主线智能体以一次**正常生成**在主线对话里追加一条短笔记（Agent Priming），让关键信息显性化、可检索，并体现“综合提炼”（去重/消冲突/抽取最有用的要点）。
+在确认该次 FBR 回贴已收齐后，主线智能体以一次**正常生成**在主线对话里追加一条短笔记（Agent Priming），让关键信息显性化、可检索，并体现“综合提炼”（去重/消冲突/抽取最有用的要点）。
 
 实现约束（与运行时一致）：
 
 - “综合提炼”阶段**不应**通过拼装/拼接一段新的 system prompt 或引入一条独立的 system-prompt 组装路径。
 - 运行时可以使用一条**internal prompt** 来锚定“本次生成就是综合提炼”。internal prompt 必须不落盘、不展示。
 - FBR 草稿与 shell 回传等“证据材料”可以通过 internal prompt 一并提供给模型（仅用于本次 drive 的上下文，不写入对话历史），从而避免依赖“支线回复注入队列”的时序与并发细节。
+- Agent Priming 生命周期（从序幕开始到 priming 笔记产出完成）内，运行时必须禁止注入 diligence-push（鞭策）消息；待 priming 结束后再恢复常规机制。
 
 实现补充（internal prompt）：