dominds 1.1.3 → 1.1.4

package/dist/access-control.js

@@ -333,10 +333,14 @@ function getAccessDeniedMessage(operation, targetPath, language = 'en') {
         lines.push('');
         if (language === 'zh') {
             lines.push(`- 说明：\`.minds/\` 是 rtws（运行时工作区）的“团队配置/记忆/资产”目录，通用文件工具无法读写（硬编码无条件拒绝）。`);
+            lines.push(`- 提示：如果你是在管理“个人记忆”，请不要尝试直接读/写/列目录 \`.minds/memory/**\`（会被拒绝）。请使用个人记忆工具：\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`。首次创建时直接 \`add_personal_memory\` 即可，目录会自动创建；\`path\` 不应包含你的成员 id。`);
+            lines.push(`- 提示：如果你是在管理“团队共享记忆”，请使用团队共享记忆工具：\`add_team_memory\` / \`replace_team_memory\` / \`drop_team_memory\` / \`clear_team_memory\`。`);
             lines.push(`- 提示：若团队配置了 \`team_mgmt\` 工具集，请使用其中工具（\`team_mgmt_*\`）代管；若未配置或你不具备权限，请诉请具备 \`team_mgmt\` 权限的成员/团队管理员成员代管。`);
         }
         else {
             lines.push(`- Note: \`.minds/\` stores rtws (runtime workspace) team config/memory/assets and is hard-denied for general file tools.`);
+            lines.push(`- Hint: If you're trying to manage **personal memory**, do not read/write/list \`.minds/memory/**\` directly (it will be denied). Use personal-memory tools: \`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`. For first-time setup, just call \`add_personal_memory\`—the directory is created automatically; \`path\` must not include your member id.`);
+            lines.push(`- Hint: If you're trying to manage **team shared memory**, use: \`add_team_memory\` / \`replace_team_memory\` / \`drop_team_memory\` / \`clear_team_memory\`.`);
             lines.push(`- Hint: If your team configured the \`team_mgmt\` toolset, use its tools (\`team_mgmt_*\`); otherwise (or if you lack access), tellask a team-admin / a member with \`team_mgmt\` access to manage it for you.`);
         }
     }

package/dist/cli/read.js

@@ -10,11 +10,44 @@
  *   --no-hints           Don't show hints
  *   --only-prompt        Show only system prompt
  *   --only-mem           Show only memories
- *   --audit              Run built-in prompt audit checks
+ *   --audit              Run prompt audit via hidden teammate @fuxi (skip when default LLM unavailable)
  *   --fail-on-audit-warning  Exit non-zero when audit emits warnings
  *   --find <pattern>     Find case-insensitive text in rendered output
  *   --help               Show help
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.main = main;
 const promises_1 = require("fs/promises");
@@ -26,7 +59,7 @@ function printUsage() {
     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('`--audit` runs prompt audit via hidden teammate @fuxi using default LLM config (skips when unavailable), and 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.");
@@ -40,118 +73,259 @@ function printUsage() {
     console.log('  dominds read ux --only-prompt --find "pending Tellask"');
     console.log('  dominds read --only-prompt --audit --fail-on-audit-warning');
 }
-function normalizeForDuplicateScan(line) {
-    return line
-        .trim()
-        .replace(/^[-*]\s+/, '')
-        .replace(/[`*_]/g, '')
-        .replace(/\s+/g, ' ')
-        .toLowerCase();
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-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\/freshBootsReasoning\/askHuman/.test(systemPrompt) ||
-                    /仅用于诉请队友\/freshBootsReasoning\/askHuman/.test(systemPrompt)),
-        },
-        {
-            id: 'fbr_phase_contract',
-            label: 'Has FBR phase contract',
-            pass: /FBR phase contract|FBR 阶段协议/.test(systemPrompt),
+function truncateForAuditInput(text, maxChars) {
+    if (text.length <= maxChars)
+        return { text, truncated: false };
+    return { text: text.slice(0, maxChars), truncated: true };
+}
+async function runFuxiAuditCall(runtime, userContent) {
+    let output = '';
+    let sawFuncCall = false;
+    const receiver = {
+        thinkingStart: async () => { },
+        thinkingChunk: async () => { },
+        thinkingFinish: async () => { },
+        sayingStart: async () => { },
+        sayingChunk: async (chunk) => {
+            output += chunk;
         },
-        {
-            id: 'taskdoc_encapsulation',
-            label: 'Has Taskdoc encapsulation section',
-            pass: /Taskdoc encapsulation & access restrictions/.test(systemPrompt) ||
-                /差遣牒.*封装/.test(systemPrompt),
+        sayingFinish: async () => { },
+        funcCall: async () => {
+            sawFuncCall = true;
         },
-    ];
-    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 context = [{ type: 'environment_msg', role: 'user', content: userContent }];
+    await runtime.llmGen.genToReceiver(runtime.providerCfg, runtime.auditAgent, runtime.auditorSystemPrompt, [], context, receiver, 0);
+    const trimmed = output.trim();
+    if (trimmed.length > 0)
+        return trimmed;
+    if (sawFuncCall)
+        return '{"verdict":"WARN","warnings":["LLM emitted tool call during prompt audit"],"rewrite":""}';
+    return '';
+}
+function parseFuxiAuditJson(raw) {
+    const start = raw.indexOf('{');
+    const end = raw.lastIndexOf('}');
+    if (start < 0 || end < start)
+        return null;
+    const candidate = raw.slice(start, end + 1);
+    let parsed;
+    try {
+        parsed = JSON.parse(candidate);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed))
+        return null;
+    const verdictRaw = parsed['verdict'];
+    if (verdictRaw !== 'PASS' && verdictRaw !== 'WARN')
+        return null;
+    const warningsRaw = parsed['warnings'];
+    if (!Array.isArray(warningsRaw))
+        return null;
+    const warnings = [];
+    for (const item of warningsRaw) {
+        if (typeof item !== 'string')
+            return null;
+        const trimmed = item.trim();
+        if (trimmed.length === 0)
+            continue;
+        warnings.push(trimmed);
+    }
+    const rewriteRaw = parsed['rewrite'];
+    const rewriteSuggestion = typeof rewriteRaw === 'string' && rewriteRaw.trim().length > 0 ? rewriteRaw.trim() : undefined;
+    return { verdict: verdictRaw, warnings, rewriteSuggestion };
+}
+async function preparePromptAuditRuntime(team) {
+    const fuxi = team.getMember('fuxi');
+    if (!fuxi) {
+        return { kind: 'skip', reason: 'Hidden teammate @fuxi is not available in current team.' };
+    }
+    const providerKey = fuxi.provider ?? team.memberDefaults.provider;
+    const modelKey = fuxi.model ?? team.memberDefaults.model;
+    if (!providerKey || !modelKey) {
+        return {
+            kind: 'skip',
+            reason: 'Default LLM provider/model is not configured for @fuxi (resolved from member + member_defaults).',
+        };
+    }
+    let providerCfg;
+    try {
+        const { LlmConfig } = await Promise.resolve().then(() => __importStar(require('../llm/client')));
+        const llmCfg = await LlmConfig.load();
+        const resolved = llmCfg.getProvider(providerKey);
+        if (!resolved) {
+            return {
+                kind: 'skip',
+                reason: `Provider '${providerKey}' is missing in effective LLM config.`,
+            };
         }
+        if (!resolved.models || !Object.prototype.hasOwnProperty.call(resolved.models, modelKey)) {
+            return {
+                kind: 'skip',
+                reason: `Model '${modelKey}' is not configured under provider '${providerKey}'.`,
+            };
+        }
+        providerCfg = resolved;
     }
-    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}`);
+    catch (err) {
+        return {
+            kind: 'skip',
+            reason: `Failed to load effective LLM config: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (providerCfg.apiType !== 'codex') {
+        const envVar = providerCfg.apiKeyEnvVar;
+        const envValue = process.env[envVar];
+        const envConfigured = typeof envValue === 'string' && envValue.trim().length > 0;
+        if (!envConfigured) {
+            return {
+                kind: 'skip',
+                reason: `Provider env var '${envVar}' is not configured (required for non-codex providers).`,
+            };
+        }
+    }
+    const { getLlmGenerator } = await Promise.resolve().then(() => __importStar(require('../llm/gen/registry')));
+    const llmGen = getLlmGenerator(providerCfg.apiType);
+    if (!llmGen) {
+        return {
+            kind: 'skip',
+            reason: `LLM generator not found for apiType='${providerCfg.apiType}'.`,
+        };
     }
-    if (hasDomindsRuntime && hasCodexHostIdentity) {
-        warnings.push('Potential host identity conflict: both Dominds runtime and Codex host identity text found.');
+    let auditorSystemPrompt;
+    try {
+        const minds = await (0, load_1.loadAgentMinds)('fuxi', undefined, { missingToolsetPolicy: 'silent' });
+        auditorSystemPrompt = minds.systemPrompt;
     }
-    if (duplicates.length > 0) {
-        warnings.push(`Detected ${duplicates.length} repeated prompt lines (top duplicates shown).`);
+    catch (err) {
+        return {
+            kind: 'skip',
+            reason: `Failed to load @fuxi minds: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const auditAgent = new team_1.Team.Member({
+        id: fuxi.id,
+        name: fuxi.name,
+        provider: providerKey,
+        model: modelKey,
+        model_params: fuxi.model_params,
+        streaming: fuxi.streaming,
+        hidden: true,
+        internal_allow_minds: true,
+    });
+    try {
+        const probe = await runFuxiAuditCall({
+            kind: 'ready',
+            auditorId: 'fuxi',
+            providerKey,
+            modelKey,
+            providerCfg,
+            llmGen,
+            auditAgent,
+            auditorSystemPrompt,
+        }, 'Connectivity check for prompt audit. Reply with a short JSON: {"verdict":"PASS","warnings":[],"rewrite":""}');
+        if (probe.trim().length === 0) {
+            return { kind: 'skip', reason: 'Connectivity probe returned empty response.' };
+        }
+    }
+    catch (err) {
+        return {
+            kind: 'skip',
+            reason: `Connectivity probe failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    return {
+        kind: 'ready',
+        auditorId: 'fuxi',
+        providerKey,
+        modelKey,
+        providerCfg,
+        llmGen,
+        auditAgent,
+        auditorSystemPrompt,
+    };
+}
+async function buildPromptAudit(targetMemberId, systemPrompt, runtime) {
+    if (runtime.kind === 'skip') {
+        return {
+            mode: 'skipped',
+            targetMemberId,
+            auditorId: 'fuxi',
+            warnings: [],
+            skipReason: runtime.reason,
+        };
+    }
+    const clipped = truncateForAuditInput(systemPrompt, 28000);
+    const userPrompt = [
+        '你是隐藏队友 @fuxi。请审计下面候选系统提示词，只关注会导致真实执行偏差/协作风险的问题，忽略纯措辞润色。',
+        '只输出 JSON，不要 markdown，不要额外解释。',
+        'JSON schema: {"verdict":"PASS|WARN","warnings":["..."],"rewrite":"..."}',
+        '- 若没有实质问题：verdict=PASS 且 warnings=[]。',
+        '- 若有问题：verdict=WARN，warnings 只列实质问题（最多 5 条）。',
+        '- rewrite 提供一段可直接替换的合并改写建议（最多 8 行）。',
+        `target_member_id: ${targetMemberId}`,
+        `prompt_truncated: ${clipped.truncated ? 'true' : 'false'}`,
+        'candidate_system_prompt:',
+        clipped.text,
+    ].join('\n\n');
+    let raw = '';
+    try {
+        raw = await runFuxiAuditCall(runtime, userPrompt);
     }
-    return { checks, duplicates, warnings };
+    catch (err) {
+        return {
+            mode: 'skipped',
+            targetMemberId,
+            auditorId: 'fuxi',
+            warnings: [],
+            skipReason: `@fuxi audit call failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    const parsed = parseFuxiAuditJson(raw);
+    if (!parsed) {
+        return {
+            mode: 'fuxi_llm',
+            targetMemberId,
+            auditorId: 'fuxi',
+            providerKey: runtime.providerKey,
+            modelKey: runtime.modelKey,
+            verdict: 'WARN',
+            warnings: ['@fuxi audit output is not valid JSON as requested'],
+            rewriteSuggestion: raw.trim().length > 0 ? raw.trim() : undefined,
+        };
+    }
+    const warnings = parsed.warnings;
+    const verdict = warnings.length === 0 ? 'PASS' : parsed.verdict;
+    return {
+        mode: 'fuxi_llm',
+        targetMemberId,
+        auditorId: 'fuxi',
+        providerKey: runtime.providerKey,
+        modelKey: runtime.modelKey,
+        verdict,
+        warnings,
+        rewriteSuggestion: parsed.rewriteSuggestion,
+    };
 }
 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`);
-        }
+    process.stdout.write(`- Target: @${report.targetMemberId}\n`);
+    if (report.mode === 'skipped') {
+        process.stdout.write('- Mode: skipped (@fuxi audit disabled due to unavailable default LLM)\n');
+        process.stdout.write(`- Reason: ${report.skipReason ?? 'unknown'}\n`);
+        process.stdout.write('- Warnings: none (audit step skipped)\n');
+        return;
     }
-    else {
-        process.stdout.write('- Duplicate Lines: none\n');
+    process.stdout.write('- Mode: @fuxi (LLM)\n');
+    if (report.providerKey && report.modelKey) {
+        process.stdout.write(`- Runtime: provider='${report.providerKey}', model='${report.modelKey}'\n`);
     }
+    process.stdout.write(`- Verdict: ${report.verdict ?? 'WARN'}\n`);
     if (report.warnings.length > 0) {
         process.stdout.write('- Warnings:\n');
         for (const warning of report.warnings) {
@@ -161,6 +335,10 @@ function printPromptAudit(report) {
     else {
         process.stdout.write('- Warnings: none\n');
     }
+    if (report.rewriteSuggestion && report.rewriteSuggestion.trim().length > 0) {
+        process.stdout.write('- Suggested Rewrite:\n');
+        process.stdout.write(`${report.rewriteSuggestion.trim()}\n`);
+    }
 }
 function listExplicitToolsets(member) {
     if (!member.toolsets)
@@ -401,6 +579,7 @@ async function main() {
         const team = await team_1.Team.load();
         const targetMemberIds = resolveTargetMemberIds(team, parsed.memberId);
         const isMultiMemberRun = targetMemberIds.length > 1;
+        const promptAuditRuntime = parsed.audit ? await preparePromptAuditRuntime(team) : undefined;
         const toolsetAudit = parsed.audit
             ? buildToolsetAuditReport({
                 team,
@@ -433,7 +612,10 @@ async function main() {
                 }
             }
             if (parsed.audit) {
-                const report = buildPromptAudit(systemPrompt);
+                const report = await buildPromptAudit(agent.id, systemPrompt, promptAuditRuntime ?? {
+                    kind: 'skip',
+                    reason: 'Prompt audit runtime was not initialized.',
+                });
                 printPromptAudit(report);
                 auditWarningCount += report.warnings.length;
             }

package/dist/docs/memory-system.md

@@ -32,7 +32,7 @@ The same information can be categorized by “who needs to see it / who maintain
 
 - **Individual-scope (per-agent / per-dialog)**:
   - `persona` / `knowledge` / `lessons` (role definitions assigned per member)
-  - individual memory (`memory`)
+  - individual memory (`personal_memory`)
   - dialog history (including tool calls and outputs)
   - reminders (working set / worklog)
 - **Collective-scope (shared by team/task)**:
@@ -102,11 +102,17 @@ Individual memory is your long-lived “how I work” asset, especially a compac
 - exact paths of key docs/code you own
 - minimal key facts (entrypoints, key symbols, local contracts)
 
-This lets you start work within your scope with “0 ripgrep”. The hard constraint is accuracy: if you change related files or detect staleness/conflicts, immediately `replace_memory` to keep it true.
+This lets you start work within your scope with “0 ripgrep”. The hard constraint is accuracy: if you change related files or detect staleness/conflicts, immediately `replace_personal_memory` to keep it true.
 
 Tools:
 
-- `add_memory` / `replace_memory` / `drop_memory` / `clear_memory`
+- `add_personal_memory` / `replace_personal_memory` / `drop_personal_memory` / `clear_personal_memory`
+
+Key notes:
+
+- Do not read/write/list `.minds/memory/**` via general file tools (it will be hard-denied). Manage personal memory via the tools above.
+- Personal memory is automatically isolated on disk under `.minds/memory/individual/<member-id>/...`, so your `path` must NOT include your member id (do not write `<member-id>/...`).
+- If you have zero personal memory entries, just call `add_personal_memory` — the directory will be created automatically.
 
 ### B) Task-term memory: Taskdoc is the single source of truth
 
@@ -202,7 +208,7 @@ The goal for agents’ day-to-day work is not “write more docs”. It’s a lo
 - **Taskdoc `constraints`**: hard rules/safety/compliance/style (must be visible to all mainlines)
 - **Team memory `team_memory`**: stable team conventions and invariants (worth reusing)
 - **Env notes `.minds/env*.md`**: rtws baseline facts, runtime constraints, gotchas (align humans + all agents to the same environment)
-- **Individual memory `memory`**: personal preferences + responsibility-area rtws index (keep accurate)
+- **Individual memory `personal_memory`**: personal preferences + responsibility-area rtws index (keep accurate)
 - **Reminders**: short-term, high-frequency details (working set / worklog; delete freely)
 - **Dialog history / tool output**: disposable by default; only keep distilled excerpts, not raw dumps
 

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

@@ -32,7 +32,7 @@ TL;DR：
 
 - **个体记忆（个人/对话局部）**：
   - `persona` / `knowledge` / `lessons`（按成员分配的角色定义）
-  - 个人记忆（`memory`）
+  - 个人记忆（`personal_memory`）
   - 对话历史（含工具调用与反馈）
   - 提醒项（工作集/工作日志）
 - **集体记忆（团队/任务共享）**：
@@ -101,11 +101,17 @@ TL;DR：
 - 你负责的关键文档/代码的**精确路径**
 - 对应的最小关键事实（入口点、关键符号、局部契约）
 
-这样你在职责范围内可以尽量做到“0 次 ripgrep 就能开工”。同时有一个硬约束：**必须保持准确**——一旦你改了相关文件或发现记忆过期/冲突，立刻用 `replace_memory` 更新。
+这样你在职责范围内可以尽量做到“0 次 ripgrep 就能开工”。同时有一个硬约束：**必须保持准确**——一旦你改了相关文件或发现记忆过期/冲突，立刻用 `replace_personal_memory` 更新。
 
 工具：
 
-- `add_memory` / `replace_memory` / `drop_memory` / `clear_memory`
+- `add_personal_memory` / `replace_personal_memory` / `drop_personal_memory` / `clear_personal_memory`
+
+关键提示：
+
+- 不要用通用文件工具去读/写/列目录 `.minds/memory/**`（会被硬拒绝）；个人记忆应通过上述个人记忆工具管理。
+- 个人记忆会自动隔离到 `.minds/memory/individual/<member-id>/...`，因此 `path` 不应包含你的成员 id（不要写 `<member-id>/...`）。
+- 若你当前没有任何个人记忆条目，直接 `add_personal_memory` 即可：目录会由系统自动创建。
 
 ### B) 中期（任务）记忆：差遣牒（Taskdoc）是单一真源
 
@@ -201,7 +207,7 @@ TL;DR：
 - **差遣牒 `constraints`**：硬规则/安全/合规/风格（必须被所有主线及时看到）
 - **团队记忆 `team_memory`**：稳定的团队约定与不变量（值得长期复用）
 - **环境提示 `.minds/env*.md`**：rtws 的基本事实、运行约束、注意事项（让人类与所有智能体对齐同一环境）
-- **个人记忆 `memory`**：个人偏好 + 职责域 rtws 索引（保持准确）
+- **个人记忆 `personal_memory`**：个人偏好 + 职责域 rtws 索引（保持准确）
 - **提醒项**：短期高频细节（工作集/工作日志，随时可删）
 - **对话历史/工具输出**：默认可丢弃；需要留的只留“精炼摘录”，不要长期背着原始转储
 

package/dist/docs/team_mgmt-toolset.md

@@ -129,7 +129,7 @@ Notes:
 - Prefer an explicit allowlist over “anything in the rtws”.
   - For `team_mgmt`, that explicit allowlist is `.minds/**` (including `.minds/memory/**`) so the
     team manager can repair accidental corruptions made by other tools (even though `.minds/memory/**`
-    already has dedicated `memory` / `team_memory` tools for normal use).
+    already has dedicated `personal_memory` / `team_memory` tools for normal use).
 - Require explicit `.minds/...` paths and validate them; do not support “implicitly scoped” paths
   like `team.yaml`.
 
@@ -429,7 +429,7 @@ member_defaults:
   model: gpt-5.2
   toolsets:
     - ws_read
-    - memory
+    - personal_memory
   # Default posture: deny `.minds/` edits for normal members.
   # (Team management should be done via `team_mgmt` tools, not general file tools.)
   no_read_dirs:

package/dist/docs/team_mgmt-toolset.zh.md

@@ -106,7 +106,7 @@
   - 拒绝包含 `..` 的路径
   - 拒绝规范化后解析到 `.minds/` 之外的任何路径
 - 优先使用显式白名单而非" rtws 中的任何内容"
-  - 对于 `team_mgmt`，该显式白名单是 `.minds/**`（包括 `.minds/memory/**`），以便团队管理者可以修复其他工具造成的意外损坏（即使 `.minds/memory/**` 已有专用的 `memory` / `team_memory` 工具供正常使用）
+- 对于 `team_mgmt`，该显式白名单是 `.minds/**`（包括 `.minds/memory/**`），以便团队管理者可以修复其他工具造成的意外损坏（即使 `.minds/memory/**` 已有专用的 `personal_memory` / `team_memory` 工具供正常使用）
 - 需要显式的 `.minds/...` 路径并验证它们；不支持像 `team.yaml` 这样的"隐式作用域"路径
 
 ### 为什么需要专用工具集（而不是仅 `read_dirs` / `write_dirs`）？
@@ -373,7 +373,7 @@ member_defaults:
   model: gpt-5.2
   toolsets:
     - ws_read
-    - memory
+    - personal_memory
   # 默认姿态：拒绝普通成员的 `.minds/` 编辑
   #（团队管理应通过 `team_mgmt` 工具完成，而非通用文件工具）
   no_read_dirs:

package/dist/minds/load.js

@@ -196,10 +196,10 @@ async function loadAgentMinds(agentId, dialog, options) {
         'clear_team_memory',
     ];
     const PERSONAL_MEMORY_TOOL_NAMES = [
-        'add_memory',
-        'replace_memory',
-        'drop_memory',
-        'clear_memory',
+        'add_personal_memory',
+        'replace_personal_memory',
+        'drop_personal_memory',
+        'clear_personal_memory',
     ];
     function isTeamMemoryToolName(name) {
         return TEAM_MEMORY_TOOL_NAMES.includes(name);
@@ -346,8 +346,8 @@ async function loadAgentMinds(agentId, dialog, options) {
             'drop_team_memory',
         ]);
         await readMemFiles(personalFiles, 'personal', personalScopeLabelText, [
-            'replace_memory',
-            'drop_memory',
+            'replace_personal_memory',
+            'drop_personal_memory',
         ]);
     }
     catch (err) {

package/dist/minds/system-prompt-parts.js

@@ -149,8 +149,9 @@ function getMemoryPromptCopy(ctx) {
             personalMemoryLine: '- 个人记忆：稳定的个人习惯/偏好与职责域知识；记忆会在每次生成时自动注入上下文，应保持少量且准确（关键文档/代码的精确路径 + 最小必要事实）。不要记录具体任务状态。',
             subdialogDutyLine: `你当前处于支线对话：此处不允许 \`change_mind\`。当你判断需要更新差遣牒（尤其是 progress 公告牌）时，请在合适时机直接诉请差遣牒维护人 \`@${ctx.taskdocMaintainerId}\` 执行更新，并给出你已合并好的“新全文/替换稿”（用于替换对应章节全文）。不要声称已更新，除非看到回执。`,
             mainlineDutyLine: '你当前处于主线对话：你负责综合维护全队共享差遣牒（尤其是 progress 公告牌）。当队友/支线对话提出更新建议时，及时合并、压缩并保持清晰。',
+            teammateTellaskRoundDoneLine: '队友诉请重要语义：当你在上游上下文中收到带【最终完成】标记的回贴，表示该轮诉请已经结束；对方不会继续执行同一轮诉请。此时如果目标未达成，“等待”是错误的：必须显式发起新一轮 tellask 才能继续推进。',
             teamMemoryHintLine: '提示：你具备团队记忆工具（`add_team_memory` / `replace_team_memory` / `drop_team_memory` / `clear_team_memory`），可在必要时维护团队记忆（谨慎、少量、只写稳定约定）。',
-            personalMemoryHintLine: '提示：你具备个人记忆工具（`add_memory` / `replace_memory` / `drop_memory` / `clear_memory`）。记忆会在每次生成时自动注入上下文：保持少量、保持准确、按“未来会一起更新的内容”合并；写稳定事实（关键路径 + 最小必要约定），不要写任务进度/当天状态；一旦你修改了相关文件或发现记忆过期/冲突，立刻用 `replace_memory` 更新。',
+            personalMemoryHintLine: `提示：你具备个人记忆工具（\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`）。个人记忆仅对当前智能体可见，且系统会自动按成员隔离到 \`.minds/memory/individual/<member-id>/...\`；因此 \`path\` 不应包含你的成员 id（不要写 \`${ctx.agentId}/...\`）。首次创建时直接用 \`add_personal_memory\` 即可，目录会由系统自动创建。记忆会在每次生成时自动注入上下文：保持少量、保持准确、按“未来会一起更新的内容”合并；写稳定事实（关键路径 + 最小必要约定），不要写任务进度/当天状态；一旦你修改了相关文件或发现记忆过期/冲突，立刻用 \`replace_personal_memory\` 更新。`,
             subdialogWorkflowLine: `工作流：先做事 → 再提炼（\`update_reminder\`；必要时整理差遣牒更新提案并诉请 \`@${ctx.taskdocMaintainerId}\` 合并写入）→ 然后 \`clear_mind\` 清空噪音。`,
             mainlineWorkflowLine: '工作流：先做事 → 再提炼（`update_reminder` + `change_mind(progress)`）→ 然后 `clear_mind` 清空噪音。',
             contextHealthLine: '系统会自动监控并提示上下文健康度：进入"吃紧"或"告急"状态时会插入用户可见提示。当收到此类提示时，立刻停止继续大实现/大阅读；先提炼，再 clear。',
@@ -171,8 +172,9 @@ function getMemoryPromptCopy(ctx) {
         personalMemoryLine: '- Personal memory: stable personal habits/preferences and responsibility-scope knowledge. Memory is automatically injected into context on each generation: keep it small and accurate (exact key doc/code paths + minimal key facts); do not store per-task state.',
         subdialogDutyLine: `You are currently in a subdialog: \`change_mind\` is not allowed here. When Taskdoc should be updated (especially the shared progress bulletin board), tellask the Taskdoc maintainer \`@${ctx.taskdocMaintainerId}\` with a fully merged replacement draft (full-section replacement). Do not claim it is updated until you see a receipt.`,
         mainlineDutyLine: 'You are currently in the main dialog: you are responsible for keeping the team-shared Taskdoc coherent and up to date (especially the progress bulletin board). Merge proposals from teammates/subdialogs promptly and keep it concise.',
+        teammateTellaskRoundDoneLine: 'Teammate Tellask semantics: when you receive an upstream reply with the 【最终完成】 marker, that Tellask round is finished; the responder will not keep executing the same call in the background. If the objective is not met, “waiting” is wrong: you must explicitly start a new Tellask round to continue.',
         teamMemoryHintLine: 'Hint: you have team-memory tools (`add_team_memory` / `replace_team_memory` / `drop_team_memory` / `clear_team_memory`) and may maintain team memory when it is truly stable and worth sharing.',
-        personalMemoryHintLine: 'Hint: you have personal-memory tools (`add_memory` / `replace_memory` / `drop_memory` / `clear_memory`). Memory is automatically injected into context on each generation: keep it small, keep it accurate, and group facts that are updated together. Store stable facts (exact key paths + minimal contracts), not daily state/progress. If you changed those files or detect staleness/conflicts, immediately `replace_memory` to keep it accurate.',
+        personalMemoryHintLine: `Hint: you have personal-memory tools (\`add_personal_memory\` / \`replace_personal_memory\` / \`drop_personal_memory\` / \`clear_personal_memory\`). Personal memory is private to the current agent and is automatically isolated under \`.minds/memory/individual/<member-id>/...\`; therefore \`path\` MUST NOT include your member id (do not write \`${ctx.agentId}/...\`). For first-time setup, just call \`add_personal_memory\`—the directory will be created automatically. Memory is automatically injected into context on each generation: keep it small, keep it accurate, and group facts that are updated together. Store stable facts (exact key paths + minimal contracts), not daily state/progress. If you changed those files or detect staleness/conflicts, immediately \`replace_personal_memory\` to keep it accurate.`,
         subdialogWorkflowLine: `Workflow: do work → distill (\`update_reminder\`; when Taskdoc needs updates, draft a merged replacement and ask \`@${ctx.taskdocMaintainerId}\`) → then \`clear_mind\` to drop noise.`,
         mainlineWorkflowLine: 'Workflow: do work → distill (`update_reminder` + `change_mind(progress)`) → then `clear_mind` to drop noise.',
         contextHealthLine: 'System will automatically monitor and alert on context health: yellow (caution/"Caution") or red (critical/"Critical") will insert a user-visible prompt. When you receive such alerts, immediately stop large implementations/reads; distill first, then clear.',
@@ -194,6 +196,7 @@ function buildMemorySystemPrompt(ctx) {
         copy.personalMemoryLine,
         '',
         ctx.isSubdialog ? copy.subdialogDutyLine : copy.mainlineDutyLine,
+        copy.teammateTellaskRoundDoneLine,
         ...(ctx.agentHasTeamMemoryTools ? [copy.teamMemoryHintLine] : []),
         ...(ctx.agentHasPersonalMemoryTools ? [copy.personalMemoryHintLine] : []),
         ctx.isSubdialog ? copy.subdialogWorkflowLine : copy.mainlineWorkflowLine,