dominds 1.1.2 → 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/apps-host/ipc-types.js

@@ -140,7 +140,9 @@ function parseAppsHostMessageFromKernel(v) {
             const grammar = asString(prompt['grammar']);
             const userLanguageCode = asLanguageCode(prompt['userLanguageCode']);
             const originRaw = asString(prompt['origin']);
-            const origin = originRaw === 'user' || originRaw === 'diligence_push' ? originRaw : undefined;
+            const origin = originRaw === 'user' || originRaw === 'diligence_push' || originRaw === 'runtime'
+                ? originRaw
+                : undefined;
             if (!content)
                 throw new Error('Invalid run_control_apply payload: prompt.content required');
             if (!msgId)

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/dialog.js

@@ -761,8 +761,8 @@ class Dialog {
     async updateQuestions4Human(questions) {
         return await this.dlgStore.updateQuestions4Human(this, questions);
     }
-    async persistUserMessage(content, msgId, grammar, userLanguageCode, q4hAnswerCallIds) {
-        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, userLanguageCode, q4hAnswerCallIds);
+    async persistUserMessage(content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds) {
+        return await this.dlgStore.persistUserMessage(this, content, msgId, grammar, origin, userLanguageCode, q4hAnswerCallIds);
     }
     async persistAgentMessage(content, genseq, type, provider_data, reasoning) {
         return await this.dlgStore.persistAgentMessage(this, content, genseq, type, provider_data, reasoning);
@@ -1153,7 +1153,7 @@ class DialogStore {
     /**
      * Persist a user message to storage
      */
-    async persistUserMessage(_dialog, _content, _msgId, _grammar, _userLanguageCode, _q4hAnswerCallIds) { }
+    async persistUserMessage(_dialog, _content, _msgId, _grammar, _origin, _userLanguageCode, _q4hAnswerCallIds) { }
     /**
      * Persist an assistant message to storage
      */

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: