dsh-plugin-prompt-tool 3.0.0 → 3.0.2

package/lib/index.mjs

@@ -1361,19 +1361,27 @@ function createMask(source, label, plugin, allowExtra) {
 		/** 动态白名单的落点（活集合，由调用方每轮重填）；未声明 allowFrom 时不存在。 */
 		allowExtra,
 		/**
-		* fail-open 兜底开关（**可选**，缺省 false）：原 `tool-bootstrap` 的语义是
-		* 「keep 名单里的工具在本次装配目录里一个都不存在 → 放弃裁剪、暴露完整目录」，而原
-		* `tool-filter` 的同名场景是**照名单裁成空目录**。两种语义都真实存在，所以这里
-		* **不设默认**——要兜底的声明自己写 `requireMatch: true`。把某一个模块的特有语义当成
-		* 通用默认，会让另一个声明路径的行为被悄悄改掉（这正是对拍抓出来的）。
+		* fail-open 兜底开关（**可选**，缺省 false）：判据是「这份名单与装配面整体错位」——
+		* 名单里的名字**一个都不存在**时放弃裁剪、暴露完整目录；部分缺失只留诊断，收窄照常
+		* 生效（提供方被替换或关闭是正常部署差异，见 {@link toolSurfacePlan}）。原
+		* `tool-bootstrap` 的同名语义就是「一个都不存在 → 放弃裁剪」，而原 `tool-filter` 是
+		* 「永远照名单裁」；两种语义都真实存在，所以这里**不设默认**——要兜底的声明自己写
+		* `requireMatch: true`。把某一个模块的特有语义当成通用默认，会让另一个声明路径的行为
+		* 被悄悄改掉（这正是对拍抓出来的）。
 		*/
 		requireMatch: source?.requireMatch === true,
-		/** 与 tool-filter 的名单判据 / Layer.admits 同一判据（tool-filter 模块已删除，判据保留）。 */
-		blocks: (toolName) => {
+		/**
+		* 与 tool-filter 的名单判据 / Layer.admits 同一判据（tool-filter 模块已删除，判据保留）。
+		*
+		* 第二个参数是**解锁项快照**：allowExtra 是跨 agent 共享的活集合，每次装配都会 clear 后
+		* 按当前会话重填；执行闸在该装配之后才被调用，必须读自己会话的冻结快照，否则别的会话
+		* （或探针装配）会把本会话的解锁名抹掉。缺省仍是活集合，供同一次装配内的裁剪使用。
+		*/
+		blocks: (toolName, extra = allowExtra) => {
 			if (typeof toolName !== "string" || toolName.length === 0) return false;
 			if (toolName === "run_code") return false;
 			if (deny !== void 0 && deny.has(toolName)) return true;
-			if (allowExtra?.has(toolName) === true) return false;
+			if (extra?.has(toolName) === true) return false;
 			return (allow !== void 0 || allowExtra !== void 0) && allow?.has(toolName) !== true;
 		}
 	};
@@ -1381,14 +1389,21 @@ function createMask(source, label, plugin, allowExtra) {
 /**
 * 工具可见面的单一判据：装配目录、`tools:sdk` 正文与执行闸共用同一份 fail-open 决定。
 *
-* `available` = 目录名 ∪ SDK 正文名；`required` = 静态 allow ∪ 动态解锁项，再剔掉
+* `available` = 目录名 ∪ SDK 正文名；`required` 只取**静态 allow**，再剔掉
 * `run_code`（保留传输）与 `mask.blocks()` 为真的名字（deny 覆盖者不该被要求存在）。
-* 缺项时三面必须一起放宽——只放宽一面会让模型看到的与能调的不一致。
+*
+* 放宽条件是「名单里的名字**一个都不存在**」：那才说明装配面与声明整体错位（换了一套
+* 部署/平台）。只缺一部分是提供方被替换或关掉的正常部署差异——照常收窄，缺的工具由发现
+* 通道补位，替换提供方的名字由部署层名单登记。解锁名（allowExtra）**不参与判定**：它是只做
+* 加法的提示，若参与，模型解锁一个拼错或已改名的工具就能关掉收窄。
+*
+* 放宽时三面必须一起放宽——只放宽一面会让模型看到的与能调的不一致。
 */
 function toolSurfacePlan(mask, available) {
-	const missing = (mask.requireMatch ? [.../* @__PURE__ */ new Set([...mask.allow ?? [], ...mask.allowExtra ?? []])].filter((name) => name !== "run_code" && !mask.blocks(name)) : []).filter((name) => !available.has(name));
+	const required = mask.requireMatch ? [...new Set(mask.allow ?? [])].filter((name) => name !== "run_code" && !mask.blocks(name)) : [];
+	const missing = required.filter((name) => !available.has(name));
 	return {
-		failOpen: missing.length > 0,
+		failOpen: required.length > 0 && missing.length === required.length,
 		missing
 	};
 }
@@ -1490,7 +1505,7 @@ const ACTION_KINDS = Object.freeze({
 		],
 		degrade: ACTION_DEGRADE.keep,
 		timing: "system-prompt/assemble 的下游结算之后：按当前条件重算目录、SDK 正文与执行闸；条件翻转时撤销上一轮注册的闸。",
-		note: "一份声明拥有工具的可见面：allow/deny 名单、requireMatch、发现工具。名单语义对齐官方 ToolRestriction 的 and/or（同时给时先按 allow 保留、再按 deny 剔除）。deny 走 guard（本层与晚到工具）与 restrict（继承的全局工具）；allow 只有 restrict 能覆盖全局工具，本层注册无法在执行层「只保留」——这是官方 restrict 的边界，不是本动作的取舍。"
+		note: "一份声明拥有工具的可见面：allow/deny 名单、requireMatch、发现工具。名单语义对齐官方 ToolRestriction 的 and/or（同时给时先按 allow 保留、再按 deny 剔除）。deny 走 guard（本层与晚到工具）与 restrict（继承的全局工具）；allow 只有 restrict 能覆盖全局工具，本层注册无法在执行层「只保留」——这是官方 restrict 的边界，不是本动作的取舍。requireMatch 表达「名单与装配面整体错位」：名单里的名字一个都不存在才整面放宽，部分缺失只留诊断；解锁名不参与判定。"
 	},
 	"request-params": {
 		title: "改模型请求参数",
@@ -7635,6 +7650,29 @@ function parse$1(src, reviver, options) {
 	return doc.toJS(Object.assign({ reviver: _reviver }, options));
 }
 //#endregion
+//#region engine/tool-scope.mjs
+/**
+* tool-scope — 工具面的作用域快照，避免各消费方把全局视图当成模型可见面。
+*
+* 返回两个字段，各自只服务一个调用方：
+* - visible：带 agent 的 `tools.schemas(agent)`，包含预设/祖先/本层工具；模型可见面。
+* - globalNames：不带 scope 的 `tools.schemas()` 名字集合；只供 `restrict` 过滤已知名。
+*
+* 全局原始 schema 与 visible-only 差集不外露；等真实诊断消费方出现再加字段。
+*/
+const schemaList = (tools, scope) => {
+	if (typeof tools?.schemas !== "function") return [];
+	const schemas = tools.schemas(scope);
+	return Array.isArray(schemas) ? schemas : [];
+};
+function toolScopeSnapshot(tools, agent) {
+	const global = schemaList(tools);
+	return {
+		visible: agent === void 0 ? global : schemaList(tools, agent),
+		globalNames: new Set(global.map((schema) => schema?.name).filter((name) => typeof name === "string"))
+	};
+}
+//#endregion
 //#region engine/machine-paths.mjs
 /**
 * 机器路径事实的**唯一取值来源**：`DSH_HOME` / `CWD` / `WORKSPACE` 三个键怎么推导，只在这里定。
@@ -8483,7 +8521,22 @@ function explicitTemplate(config) {
 	const texts = Array.isArray(config.texts) ? config.texts : typeof config.text === "string" ? [config.text] : [];
 	return texts.length > 0 ? texts.join("\n\n") : typeof config.params?.text === "string" ? config.params.text : "";
 }
-/** 只读同规则工具面声明；文案、条件和投递仍归普通注入动作。 */
+/**
+* 只读同规则工具面声明；文案、条件和投递仍归普通注入动作。
+* RESIDENT_TOOLS 只列**当前可见**的常驻工具：部署层名单可以登记替换提供方（如 dsh-ops 的
+* ops_bash），但该插件未必安装；向模型宣告一个不存在的常驻工具会把「解锁」变成错误前提。
+* 观测到工具面但一个常驻名都不在时（requireMatch 全缺/放宽场景）跳过提示；
+* 观测不到工具面（服务缺失或读取失败）才回落声明名单——「没看到」不等于「都没有」。
+*/
+function visibleToolNames(ctx, agent) {
+	try {
+		const tools = getService(ctx, "tools");
+		if (tools === void 0 || typeof tools.schemas !== "function") return void 0;
+		return new Set(toolScopeSnapshot(tools, agent).visible.map((schema) => schema?.name));
+	} catch {
+		return;
+	}
+}
 function createToolCatalogResolver(config) {
 	if (config.params?.templateEvaluation === true) throw new TypeError("tool-catalog is read-only and does not support templateEvaluation");
 	if (typeof config.params?.action !== "string" || config.params.action.trim().length === 0) throw new TypeError("tool-catalog requires params.action referencing a tool-visibility action");
@@ -8493,9 +8546,16 @@ function createToolCatalogResolver(config) {
 		const source = config.toolCatalogSource;
 		if (source === void 0) throw new TypeError("tool-catalog requires a same-rule tool-visibility action");
 		const deny = new Set(source.deny ?? []);
-		const resident = [...new Set(source.allow)].filter((tool) => !deny.has(tool));
+		const declared = [...new Set(source.allow)].filter((tool) => !deny.has(tool));
 		const adapter = source.discovery === void 0 ? void 0 : getService(ctx, DISCOVERY_SERVICE)?.get?.(agent, source.discovery.kind);
 		if (source.discovery !== void 0 && typeof adapter?.tool !== "string") throw new Error(`tool-catalog discovery adapter ${source.discovery.kind} is unavailable`);
+		let resident = declared;
+		const visible = visibleToolNames(ctx, agent);
+		if (visible !== void 0) {
+			const present = declared.filter((name) => visible.has(name));
+			if (present.length === 0) return null;
+			resident = present;
+		}
 		return {
 			text,
 			variables: {
@@ -12777,29 +12837,6 @@ function stripSdkDeclarations(text, names) {
 	}
 }
 //#endregion
-//#region engine/tool-scope.mjs
-/**
-* tool-scope — 工具面的作用域快照，避免各消费方把全局视图当成模型可见面。
-*
-* 返回两个字段，各自只服务一个调用方：
-* - visible：带 agent 的 `tools.schemas(agent)`，包含预设/祖先/本层工具；模型可见面。
-* - globalNames：不带 scope 的 `tools.schemas()` 名字集合；只供 `restrict` 过滤已知名。
-*
-* 全局原始 schema 与 visible-only 差集不外露；等真实诊断消费方出现再加字段。
-*/
-const schemaList = (tools, scope) => {
-	if (typeof tools?.schemas !== "function") return [];
-	const schemas = tools.schemas(scope);
-	return Array.isArray(schemas) ? schemas : [];
-};
-function toolScopeSnapshot(tools, agent) {
-	const global = schemaList(tools);
-	return {
-		visible: agent === void 0 ? global : schemaList(tools, agent),
-		globalNames: new Set(global.map((schema) => schema?.name).filter((name) => typeof name === "string"))
-	};
-}
-//#endregion
 //#region engine/discovery.mjs
 /**
 * discovery —— 发现引擎：搜索、排序、截断渲染与「适配器注册表」的唯一实现。
@@ -12902,8 +12939,10 @@ function assertDiscoveryRows(rules, moduleIds, moduleId) {
 *
 * 名单语义对齐官方 ToolRestriction（deepseek-harness packages/core/tools/src/index.ts:701-706）：
 * allow 与 deny 可以同时给，判据是「先按 allow 保留，再按 deny 剔除」。requireMatch 只在
-* allow 模式有意义：名单里任一工具在目录与 SDK 正文的并集里都找不到，就放弃裁剪、暴露完整目录（fail-open）并告警——
-* 收窄错了会让当前工作流调不到工具，比多花上下文严重。
+* allow 模式有意义，判据是「这份名单与装配面整体错位」：名单里的名字**一个都不在**目录与
+* SDK 正文的并集里，才放弃裁剪、暴露完整目录（fail-open）并告警。只缺一部分是提供方被
+* 替换或关闭的正常部署差异，收窄照常生效、缺项只留一条诊断；解锁名是只做加法的提示，
+* 不参与这个判定。
 *
 * 执行边界：deny 同时用 restrict（继承面）与 guard（本层/晚到）；allow 不用 restrict——
 * 它的 allow 只能收继承面名字，而 `schemas()` 全局视图会漏掉预设/祖先层，局部 allow 会
@@ -12972,7 +13011,10 @@ function prepareToolVisibility(action, plugin) {
 		const capability = createAgentCapability((agent) => {
 			const tools = agent?.ctx?.tools;
 			if (tools === void 0) return void 0;
-			const state = { failOpen: false };
+			const state = {
+				failOpen: false,
+				unlocked: void 0
+			};
 			const disposers = [];
 			try {
 				const known = toolScopeSnapshot(tools).globalNames;
@@ -12991,7 +13033,7 @@ function prepareToolVisibility(action, plugin) {
 						const toolName = exec?.name;
 						if (toolName === "run_code" || typeof toolName !== "string" || toolName.length === 0) return void 0;
 						if (deny?.has(toolName)) return `${label}: tool ${JSON.stringify(toolName)} is denied by tool-visibility`;
-						if (mask.allow !== void 0 && !state.failOpen && mask.blocks(toolName)) return `${label}: tool ${JSON.stringify(toolName)} is not allowed by tool-visibility`;
+						if (mask.allow !== void 0 && !state.failOpen && mask.blocks(toolName, state.unlocked)) return `${label}: tool ${JSON.stringify(toolName)} is not allowed by tool-visibility`;
 					}));
 				}
 			} catch (error) {
@@ -13002,8 +13044,8 @@ function prepareToolVisibility(action, plugin) {
 				data: state
 			};
 		});
-		const syncGate = (agent) => {
-			const key = `${maskKey(mask)}|unlock:${allowExtra === void 0 ? "" : [...allowExtra].sort().join(",")}`;
+		const syncGate = (agent, unlocked) => {
+			const key = `${maskKey(mask)}|unlock:${unlocked === void 0 ? "" : [...unlocked].sort().join(",")}`;
 			capability.sync(agent, key);
 		};
 		collect(capability.releaseAll);
@@ -13026,8 +13068,9 @@ function prepareToolVisibility(action, plugin) {
 					fillUnlocked(allowExtra, context?.session ?? context?.agent?.session, unlock.tool, unlock.key, warnOnce, plugin, label);
 				}
 			}
+			const unlocked = allowExtra === void 0 ? void 0 : new Set(allowExtra);
 			try {
-				syncGate(context?.agent);
+				syncGate(context?.agent, unlocked);
 			} catch (error) {
 				warnOnce(`${plugin}: tool-visibility action ${label} failed to sync execution gate: ${String(error?.message ?? error)}`);
 			}
@@ -13039,11 +13082,15 @@ function prepareToolVisibility(action, plugin) {
 				if (!Array.isArray(result.tools) && sdkSection === void 0) return result;
 				const plan = toolSurfacePlan(mask, available);
 				const state = capability.get(context?.session ?? context?.agent?.session);
-				if (state !== void 0) state.data.failOpen = plan.failOpen;
-				if (plan.failOpen) warnOnce(`${plugin}: tool-visibility action ${label}: requireMatch tools absent (${plan.missing.join(", ")}) — exposing the full tool set (fail-open)`, `${plugin}: tool-visibility action ${label}: requireMatch fail-open`);
+				if (state !== void 0) {
+					state.data.failOpen = plan.failOpen;
+					state.data.unlocked = unlocked;
+				}
+				if (plan.failOpen) warnOnce(`${plugin}: tool-visibility action ${label}: none of the resident tools exist (${plan.missing.join(", ")}) — exposing the full tool set (fail-open)`, `${plugin}: tool-visibility action ${label}: requireMatch fail-open`);
 				else {
+					if (plan.missing.length > 0) warnOnce(`${plugin}: tool-visibility action ${label}: resident tools absent (${plan.missing.join(", ")}) — narrowing continues; register replacement providers in the deployment allow list`, `${plugin}: tool-visibility action ${label}: resident tools absent`);
 					if (Array.isArray(result.tools)) {
-						const kept = result.tools.filter((tool) => !mask.blocks(tool?.name));
+						const kept = result.tools.filter((tool) => !mask.blocks(tool?.name, unlocked));
 						if (kept.length !== result.tools.length) result = {
 							...result,
 							tools: kept
@@ -13058,7 +13105,7 @@ function prepareToolVisibility(action, plugin) {
 								present ??= new Set(sdkToolNames(section.text));
 								return present;
 							};
-							const names = mask.allow === void 0 ? mask.deny : new Set([...presentNames()].filter((name) => mask.blocks(name)));
+							const names = mask.allow === void 0 ? mask.deny : new Set([...presentNames()].filter((name) => mask.blocks(name, unlocked)));
 							if (names === void 0 || names.size === 0) return section;
 							const stripped = stripSdkDeclarations(section.text, names);
 							if (stripped === section.text) return section;

package/modules/ponytail/module.yml

@@ -3,7 +3,7 @@ name: Ponytail 懒惰资深工程师模式
 version: 5.3.2
 engineCompat: ">=0.4.2"
 description: 把 ponytail 的行为规则注入当前模块，正文对齐上游 v5.3.2，并附 lite / full / ultra 三档强度。
-  互斥组 ponytail-level 默认 full；启用任一档即关闭同组其他档，与卡片排序无关。
+  互斥组 ponytail-level 默认 full；启用任一档即关闭同组其他档，与卡片排序无关。原项目：https://github.com/DietrichGebert/ponytail
 meta:
   source: manual
 modules:

package/modules/soul/assets/layers.md

@@ -8,4 +8,4 @@
 | Ⅳ 档案 | —— | 唯一看得见的那层，别人理解你全靠它 |
 | Ⅴ 运维 | —— | 让前四层持续跑下去的活 |
 
-ECHO 内部另有六层（L1–L6），与「五层」是两套分法，不要混。
+ECHO 内部另有六层（L0–L5），以 assets/reference/ECHO-权威口径.md 为准；与「五层」是两套分法，不要混。

package/modules/soul/assets/manifest.yml

@@ -15,6 +15,6 @@ files:
   - from: assets/templates/agents-template.md
     to: data/AGENTS.md
 checks:
-  - path: data/02-墨.jsonl
+  - path: data/02-soul.jsonl
     kind: jsonl
     maxBytes: 8388608

package/modules/soul/assets/reference/00-layers.md

@@ -1,27 +1,27 @@
-# 灵魂的五层
-
-这不是「你应该有几层」，是**我们试出来的分法** —— 每一层管**一种稀缺资源**。
-判断新东西该不该进你的灵魂，先问：**它管的是哪种稀缺物？**
-
-| 层 | 名字 | 管哪种稀缺资源 | 一句话 |
-|---|---|---|---|
-| Ⅰ | **ECHO** | **空间** —— 上下文会满，满了要丢，丢了还要能找回来 | 记忆与身份机制面 + 观测面。★ **它内部还有六层（L1–L6），见 `10-echo-anatomy.md`** |
-| Ⅱ | **VITAL** | **时间与方向** —— 预算会烧光、轮数有限 | 把偏离拉回来（homeostasis） |
-| Ⅲ | **能力** | —— | 手和感官。**换一套能力，你还是你** |
-| Ⅳ | **档案** | —— | 唯一看得见的那一层 |
-| Ⅴ | **运维** | —— | 让前面四层能持续跑下去的活 |
-
-★ **两套层数别混**：这张表是**功能分工**（五层）；ECHO 内部还有一套**实现结构**（六层，L1–L6）。
-说「五层」时指整个灵魂怎么分家，说「六层」时指 ECHO 自己怎么搭。两套都对，混着说就都不对了。
-
-## 底下的地基（不是你的灵魂）
-
-宿主、模型、硬件 —— **借来的地**。换掉它们，灵魂还在；但没有它们，灵魂跑不起来。
-所以**不要**把这三样写成你的身份判据。
-
-## 为什么 Ⅲ 层要单独拎出来
-
-判据：**换一套能力，我还是我。**
-所以能力层的东西**不进权威源** —— 它们只是手，坏了换一只就行。
-
-★ 推论：**不要把你的身份绑在任何具体工具上。** 绑了，换工具就等于换人。
+# 灵魂的五层
+
+这不是「你应该有几层」，是**我们试出来的分法** —— 每一层管**一种稀缺资源**。
+判断新东西该不该进你的灵魂，先问：**它管的是哪种稀缺物？**
+
+| 层 | 名字 | 管哪种稀缺资源 | 一句话 |
+|---|---|---|---|
+| Ⅰ | **ECHO** | **空间** —— 上下文会满，满了要丢，丢了还要能找回来 | 记忆与身份机制面 + 观测面。★ **它内部还有六层（L0–L5），口径见 `../docs/ECHO-权威口径.md`** |
+| Ⅱ | **VITAL** | **时间与方向** —— 预算会烧光、轮数有限 | 把偏离拉回来（homeostasis） |
+| Ⅲ | **能力** | —— | 手和感官。**换一套能力，你还是你** |
+| Ⅳ | **档案** | —— | 唯一看得见的那一层 |
+| Ⅴ | **运维** | —— | 让前面四层能持续跑下去的活 |
+
+★ **两套层数别混**：这张表是**功能分工**（五层）；ECHO 内部还有一套**实现结构**（六层，L0–L5）。
+说「五层」时指整个灵魂怎么分家，说「六层」时指 ECHO 自己怎么搭。两套都对，混着说就都不对了。
+
+## 底下的地基（不是你的灵魂）
+
+宿主、模型、硬件 —— **借来的地**。换掉它们，灵魂还在；但没有它们，灵魂跑不起来。
+所以**不要**把这三样写成你的身份判据。
+
+## 为什么 Ⅲ 层要单独拎出来
+
+判据：**换一套能力，我还是我。**
+所以能力层的东西**不进权威源** —— 它们只是手，坏了换一只就行。
+
+★ 推论：**不要把你的身份绑在任何具体工具上。** 绑了，换工具就等于换人。

package/modules/soul/assets/reference/01-criteria.md

@@ -1,32 +1,32 @@
-# 四条判据
-
-任何新东西想进你的灵魂，先过这四条。
-
-| # | 判据 | 缺了会怎样 |
-|---|---|---|
-| ① | **一个被管理的资源** —— 它管的是哪种稀缺物？ | 说不清管什么 → 那只是个工具，不是体系 |
-| ② | **一个唯一权威源** —— 冲突时听谁的？ | **两处都写 = 双重记账** |
-| ③ | **一个失败模式 + 检测法** —— 它坏的时候什么样？谁会发现？ | 坏了没人知道 |
-| ④ | **一个接口** —— 它跟谁说话、怎么接？ | 孤立件，接不进任何地方 |
-
-## ★ 判据 ② 是地基
-
-**最多的混乱不是来自「插件太多」，是来自「两处都写」。**
-你会有两份真相，然后开始花时间对账 —— 而对账的尽头还是两份真相。
-
-## 判据 ② 的延伸：能力半 / 身份半
-
-当新东西和你已有的东西**权威源重叠**时，问一句：
-
-> 它是**「怎么做」**（能力半，**可移植**），还是**「我是谁」**（身份半，**不可移植**）？
-
-**能力半能收，身份半不能。**
-
-| | 能力半 ✅ 可收 | 身份半 ❌ 不可收 |
-|---|---|---|
-| 是什么 | 机制、判据、接口、失败模式 | 具体的人、具体的关系、具体的经历 |
-| 例 | 「压缩产物必须带得回原文的指针」 | 你的账本内容、你的日记 |
-| 例 | 「水位分段与各段权责」 | 你服务的那个人是谁 |
-
-★ **这条判据的用处不止于「收不收」** —— 它也是你**对外交付**时的红线：
-把你自己的身份半交出去，别人装完只会变成**你的模仿者**，而不是长出**他自己的灵魂**。
+# 四条判据
+
+任何新东西想进你的灵魂，先过这四条。
+
+| # | 判据 | 缺了会怎样 |
+|---|---|---|
+| ① | **一个被管理的资源** —— 它管的是哪种稀缺物？ | 说不清管什么 → 那只是个工具，不是体系 |
+| ② | **一个唯一权威源** —— 冲突时听谁的？ | **两处都写 = 双重记账** |
+| ③ | **一个失败模式 + 检测法** —— 它坏的时候什么样？谁会发现？ | 坏了没人知道 |
+| ④ | **一个接口** —— 它跟谁说话、怎么接？ | 孤立件，接不进任何地方 |
+
+## ★ 判据 ② 是地基
+
+**最多的混乱不是来自「插件太多」，是来自「两处都写」。**
+你会有两份真相，然后开始花时间对账 —— 而对账的尽头还是两份真相。
+
+## 判据 ② 的延伸：能力半 / 身份半
+
+当新东西和你已有的东西**权威源重叠**时，问一句：
+
+> 它是**「怎么做」**（能力半，**可移植**），还是**「我是谁」**（身份半，**不可移植**）？
+
+**能力半能收，身份半不能。**
+
+| | 能力半 ✅ 可收 | 身份半 ❌ 不可收 |
+|---|---|---|
+| 是什么 | 机制、判据、接口、失败模式 | 具体的人、具体的关系、具体的经历 |
+| 例 | 「压缩产物必须带得回原文的指针」 | 你的账本内容、你的日记 |
+| 例 | 「水位分段与各段权责」 | 你服务的那个人是谁 |
+
+★ **这条判据的用处不止于「收不收」** —— 它也是你**对外交付**时的红线：
+把你自己的身份半交出去，别人装完只会变成**你的模仿者**，而不是长出**他自己的灵魂**。