psyclaw 0.27.5 → 0.27.7

package/dist/src/adapters/pi/extension.js

@@ -6,12 +6,14 @@ import { atomicWriteFile } from "../../project/jsonl.js";
 import { RunEventLog } from "../../panel/events.js";
 import { readProject } from "../../research/ledger.js";
 import { join } from "node:path";
-import { mkdir, readFile } from "node:fs/promises";
+import { lstat, mkdir, readFile } from "node:fs/promises";
 import { PROVIDER_PRESETS, saveProviderConfig } from "../../setup.js";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { coreSkillNames, enabledRecommendedSkillPaths, normalizeRecommendedSkillId, readRecommendationState, readRecommendedCatalog, recommendedSkillTarget, saveRecommendationState, validateModelInstalledRecommendedSkill, } from "../../skills/recommended.js";
 import { SkillManagerComponent } from "../../tui/skill-manager.js";
+import { enabledLocalSkillPaths, enabledLocalPromptPaths, readUserSkillState, scanLocalSkills, setLocalSkillEnabled, setLocalSkillsEnabled, skillNamesInPaths, userSkillId, } from "../../skills/user-skills.js";
+import { RuntimeMcpRegistry, setUserMcpConfigEnabled, } from "../../integrations/mcp-runtime.js";
 import { ProviderPickerComponent, SecretInputComponent, } from "../../tui/provider-picker.js";
 const PARADIGMS = new Set([
     "survey-observational",
@@ -163,28 +165,32 @@ async function readControlledRun(root) {
     try {
         const value = JSON.parse(await readFile(await controlledRunPath(root), "utf8"));
         return value.schemaVersion === "psyclaw/controlled-run/v1" && value.status === "active" && typeof value.projectId === "string" && typeof value.objective === "string" && typeof value.activatedAt === "string"
-            ? value
+            ? { ...value, selectedSkills: Array.isArray(value.selectedSkills) ? value.selectedSkills.filter((item) => typeof item === "string") : [] }
             : null;
     }
     catch {
         return null;
     }
 }
-async function activateControlledRun(root, projectId, objective) {
+async function activateControlledRun(root, projectId, objective, selectedSkills) {
     const state = {
         schemaVersion: "psyclaw/controlled-run/v1",
         projectId,
         objective,
+        selectedSkills: [...new Set(selectedSkills)],
         activatedAt: new Date().toISOString(),
         status: "active",
     };
     await atomicWriteFile(await controlledRunPath(root), `${JSON.stringify(state, null, 2)}\n`);
     return state;
 }
-function controlledRunRequest(objective) {
+function controlledRunRequest(objective, selectedSkills) {
     return [
         "PsyClaw 受控研究流程已由用户通过 /run 明确启动。先读取 .psyclaw/project.json、.psyclaw/controlled-run.json、notes/research-spec.md 和 notes/plan.md。",
         `本次目标：${objective}`,
+        selectedSkills.length > 0
+            ? `本次运行由用户选择的优化 Skill：${selectedSkills.join(", ")}。在相关任务中优先加载并遵循这些 Skill；同名 Skill 只加载一次。`
+            : "本次运行未指定额外 Skill，使用 PsyClaw 默认研究流程。不要删除、停用或改写已安装的其他 Skill。",
         "实际推进当前尚未完成的研究任务；先形成或更新符合学术规范的 Markdown 分析报告，不能只描述计划。分析报告必须清楚区分数据来源、统计结果、文献证据、限制与尚未核验内容。",
         "分析报告完成后，下一步不是直接询问是否导出 DOCX，而是询问用户是否据此撰写论文。",
         "若用户选择撰写论文，再单独询问是否先进行文献调研，并说明该阶段可能花费较长时间；提示用户可以指定已启用的 Skill，或者选择 PsyClaw 默认的文献调研方式。不要在获得答复前自动开始长时调研。",
@@ -194,6 +200,53 @@ function controlledRunRequest(objective) {
         "如果用户在未完成文献调研、全文写作或评审前要求导出 DOCX，允许导出当前分析报告，但必须明确标为遵循学术规范的分析报告，不得称为论文。",
     ].join("\n");
 }
+function parseRunArgs(args) {
+    const value = args.trim();
+    if (!value.startsWith("--skills"))
+        return { objective: value };
+    const match = value.match(/^--skills(?:=|\s+)([^\s]+)(?:\s+([\s\S]*))?$/);
+    if (!match)
+        throw new Error("Usage: /run [--skills skill-a,skill-b] [objective]");
+    return {
+        objective: (match[2] ?? "").trim(),
+        requestedSkills: [...new Set(match[1].split(",").map((item) => item.trim()).filter(Boolean))],
+    };
+}
+async function selectableRunSkills(root) {
+    const state = await readRecommendationState(root);
+    const rows = await skillManagerRows(root, state);
+    const available = [
+        ...coreSkillNames().map((name) => ({ id: name, name })),
+        ...rows.filter((row) => row.installed && row.enabled && !row.blocked).map((row) => ({ id: row.id, name: row.name })),
+    ];
+    const seen = new Set();
+    return available.filter((skill) => {
+        const key = skill.name.trim().toLocaleLowerCase();
+        if (!key || seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function resolveRunSkills(requested, available) {
+    const lookup = new Map();
+    for (const skill of available) {
+        lookup.set(skill.id.toLocaleLowerCase(), skill.name);
+        lookup.set(skill.name.toLocaleLowerCase(), skill.name);
+    }
+    const selected = [];
+    const unknown = [];
+    for (const value of requested) {
+        const name = lookup.get(value.toLocaleLowerCase());
+        if (!name)
+            unknown.push(value);
+        else if (!selected.some((item) => item.toLocaleLowerCase() === name.toLocaleLowerCase()))
+            selected.push(name);
+    }
+    if (unknown.length > 0)
+        throw new Error(`本次运行不可用的 Skill：${unknown.join(", ")}。请先通过 /skills 安装或启用。`);
+    return selected;
+}
 async function recommendedItems(kind) {
     const file = kind === "skills" ? "catalog.json" : "mcp-catalog.json";
     const moduleDir = dirname(fileURLToPath(import.meta.url));
@@ -217,11 +270,13 @@ async function recommendedItems(kind) {
     return { items: [], externalTools: [], installPrep: [] };
 }
 function skillScopeLabel(scope) {
+    if (scope === "local")
+        return "用户本地目录（所有项目可发现）";
     return scope === "user" ? "系统目录（所有项目）" : "项目目录（仅当前项目）";
 }
 async function skillManagerRows(root, state) {
     const catalog = await readRecommendedCatalog();
-    return Promise.all(catalog.items.filter((item) => item.kind === "skill").map(async (item) => {
+    const recommendedRows = await Promise.all(catalog.items.filter((item) => item.kind === "skill").map(async (item) => {
         const id = normalizeRecommendedSkillId(item.id);
         const scope = state.skillScopes?.[id] ?? "project";
         try {
@@ -237,9 +292,21 @@ async function skillManagerRows(root, state) {
                 enabled: state.skills.includes(id),
                 scope,
                 blocked: false,
+                source: "recommended",
             };
         }
-        catch {
+        catch (validationError) {
+            // A managed target that exists on disk but fails validation (e.g. a URL
+            // install whose manifest/hash does not match the pinned catalog) is still
+            // shown as installed so the user sees it; enabling it only takes effect
+            // once the install is repaired through /install.
+            let onDisk = false;
+            try {
+                const target = recommendedSkillTarget(root, id, scope);
+                const stat = await lstat(target);
+                onDisk = stat.isDirectory();
+            }
+            catch { /* target missing */ }
             return {
                 id,
                 name: item.name,
@@ -247,20 +314,50 @@ async function skillManagerRows(root, state) {
                 ...(item.sourceRef === undefined ? {} : { sourceRef: item.sourceRef }),
                 ...(typeof item.installHint === "string" ? { installHint: item.installHint } : {}),
                 collection: item.skillLayout === "collection",
-                installed: false,
-                enabled: false,
+                installed: onDisk,
+                enabled: onDisk && state.skills.includes(id),
                 scope,
                 blocked: typeof item.sourceRef !== "string" || !/^https:\/\//.test(item.sourceRef),
-                reason: typeof item.sourceRef === "string" && /^https:\/\//.test(item.sourceRef)
-                    ? "尚未安装；按 Enter 选择安装范围并交给当前模型处理"
-                    : "没有可交给模型检查的来源网址",
+                reason: onDisk
+                    ? `已检测到目录但未通过来源/许可/哈希校验${state.skills.includes(id) ? "（当前配置为启用，但校验失败不会加载）" : ""}；可按 Enter 重新安装修复`
+                    : typeof item.sourceRef === "string" && /^https:\/\//.test(item.sourceRef)
+                        ? "尚未安装；按 Enter 选择安装范围并交给当前模型处理"
+                        : "没有可交给模型检查的来源网址",
+                source: "recommended",
             };
         }
     }));
+    // Merge user-installed local skills from the expanded discovery roots so the
+    // management page shows them and lets the user toggle each one.  Managed
+    // recommended installs are excluded here — they are shown through their
+    // recommended rows above (including on-disk-but-unvalidated installs).
+    const userState = await readUserSkillState(root);
+    const disabled = new Set(userState.disabled);
+    const localSkills = await scanLocalSkills(root, { includeManaged: false });
+    const localRows = localSkills.map((skill) => ({
+        id: userSkillId(skill.name),
+        name: skill.name,
+        description: skill.description,
+        sourceRef: skill.path,
+        collection: false,
+        installed: true,
+        enabled: !disabled.has(skill.name),
+        scope: "local",
+        blocked: false,
+        source: "local",
+        duplicatePaths: skill.duplicatePaths,
+    }));
+    // A catalog skill that is actually installed is shown once through its
+    // recommended row (which carries source/trust info); purely local skills —
+    // including a local copy of a catalog skill that failed managed validation —
+    // are appended so they stay visible and toggleable.
+    const installedRecommendedNames = new Set(recommendedRows.filter((row) => row.installed).map((row) => row.name.toLocaleLowerCase()));
+    const uniqueLocalRows = localRows.filter((row) => !installedRecommendedNames.has(row.name.toLocaleLowerCase()));
+    return [...recommendedRows, ...uniqueLocalRows];
 }
-async function mcpManagerRows(state) {
+async function mcpManagerRows(root, state, runtime) {
     const { items, installPrep } = await recommendedItems("mcp");
-    return items.map((item) => {
+    const recommendedRows = items.map((item) => {
         const id = String(item.id ?? "");
         const plan = installPrep.find((candidate) => candidate.id === id);
         const dependencies = Array.isArray(plan?.dependencies)
@@ -272,6 +369,7 @@ async function mcpManagerRows(state) {
             description: String(item.description ?? ""),
             ...(typeof item.sourceRef === "string" ? { sourceRef: item.sourceRef } : {}),
             enabled: state.mcp.includes(id),
+            source: "recommended",
             details: [
                 `传输：${String(item.transport ?? "未声明")} · 风险：${String(item.risk ?? "未声明")}`,
                 `参考版本：${String(plan?.ref ?? "由模型读取来源确定")} · 许可证：${String(plan?.license ?? "由模型读取来源确定")}`,
@@ -279,6 +377,31 @@ async function mcpManagerRows(state) {
             ],
         };
     });
+    // Merge user-configured MCP servers (`.psyclaw/mcp/*.json` and
+    // `~/.psyclaw/mcp/*.json`) so the management page shows them too, even when
+    // disabled.  User rows win over a same-id recommended row.
+    const userRows = (await runtime.listUserConfigs(root)).map((entry) => ({
+        id: entry.id,
+        name: entry.name,
+        description: `用户配置：${entry.command}`,
+        enabled: entry.enabled,
+        source: "user",
+        userEntry: entry,
+        details: [
+            `传输：stdio · 范围：${entry.scope === "user" ? "用户级" : "项目级"}`,
+            `配置：${entry.path}`,
+        ],
+    }));
+    const merged = new Map(recommendedRows.map((row) => [row.id, row]));
+    for (const row of userRows)
+        merged.set(row.id, row);
+    return [...merged.values()].sort((left, right) => {
+        if (left.source === "user" && right.source !== "user")
+            return -1;
+        if (right.source === "user" && left.source !== "user")
+            return 1;
+        return left.id.localeCompare(right.id);
+    });
 }
 function skillRowLabel(row) {
     const state = row.blocked ? "× 阻断" : row.enabled ? "● 已启用" : row.installed ? "○ 未启用" : "↓ 未安装";
@@ -314,7 +437,12 @@ function skillManagerItems(rows) {
             description: row.description,
             status: row.blocked ? "blocked" : row.enabled ? "enabled" : row.installed ? "disabled" : "missing",
             ...(row.sourceRef === undefined ? {} : { sourceRef: row.sourceRef }),
-            details: [`安装位置：${skillScopeLabel(row.scope)}`],
+            details: [
+                `安装位置：${skillScopeLabel(row.scope)}`,
+                ...(row.duplicatePaths && row.duplicatePaths.length > 0
+                    ? [`已忽略 ${row.duplicatePaths.length} 个同名来源`]
+                    : []),
+            ],
             ...(row.reason === undefined ? {} : { reason: row.reason }),
         })),
     ];
@@ -337,18 +465,14 @@ async function openMcpManager(ctx, rows) {
     return ctx.ui.custom((tui, theme, keybindings, done) => (new SkillManagerComponent(mcpManagerItems(rows), tui, theme, keybindings, done, {
         title: "MCP 管理",
         itemLabel: "MCP",
-        footer: "↑/↓ 移动 · Space 开启/关闭项目配置 · Enter 交给模型安装并配置 · Esc 关闭",
+        footer: "↑/↓ 移动 · Space 开启/关闭 · a 全部开启 · d 全部关闭 · Enter 交给模型安装并配置 · Esc 关闭",
         enterAction: "install",
-        enabledText: "项目配置已开启；Enter 可让当前模型重新安装或修复配置",
-        disabledText: "项目配置已关闭",
+        enabledText: "已开启；Enter 可让当前模型重新安装或修复推荐配置",
+        disabledText: "已关闭",
     })));
 }
 async function setRecommendedMcpEnabled(root, id, enabled) {
     const state = await readRecommendationState(root);
-    const rows = await mcpManagerRows(state);
-    const row = rows.find((candidate) => candidate.id === id);
-    if (!row)
-        throw new Error(`未找到推荐 MCP: ${id}`);
     const current = new Set(state.mcp);
     if (enabled)
         current.add(id);
@@ -357,6 +481,9 @@ async function setRecommendedMcpEnabled(root, id, enabled) {
     state.mcp = [...current];
     await saveRecommendationState(root, state);
 }
+async function setUserMcpEnabled(entry, enabled) {
+    await setUserMcpConfigEnabled(entry, enabled);
+}
 function modelMcpInstallTask(root, row, plan) {
     const suggestedCommand = typeof plan?.command === "string" ? plan.command : "请根据来源仓库的最新安装说明确定";
     const suggestedTarget = typeof plan?.target === "string" ? plan.target : `.psyclaw/mcp/${row.id}.json`;
@@ -379,48 +506,86 @@ async function queueModelMcpInstall(pi, ctx, row, plan) {
     pi.sendUserMessage(modelMcpInstallTask(ctx.cwd, row, plan), ctx.isIdle() ? {} : { deliverAs: "followUp" });
     ctx.ui.notify(`已将 ${row.name} 的下载、安装和配置任务交给当前模型。模型完成并确认可启动后，请执行 /reload。`, "info");
 }
-async function showMcpManager(pi, args, ctx) {
+async function showMcpManager(pi, args, ctx, runtime) {
     const [verb, id] = args.trim().split(/\s+/).filter(Boolean);
-    if (verb && !["status", "enable", "disable", "install"].includes(verb)) {
-        throw new Error("Usage: /mcp [status|enable <id>|disable <id>|install <id>]");
+    if (verb && !["status", "enable", "disable", "enable-all", "disable-all", "install"].includes(verb)) {
+        throw new Error("Usage: /mcp [status|enable <id>|disable <id>|enable-all|disable-all|install <id>]");
     }
     if ((verb === "enable" || verb === "disable" || verb === "install") && !id) {
         throw new Error(`Usage: /mcp ${verb} <id>`);
     }
     const catalog = await recommendedItems("mcp");
     if (verb === "install") {
-        const rows = await mcpManagerRows(await readRecommendationState(ctx.cwd));
+        const rows = await mcpManagerRows(ctx.cwd, await readRecommendationState(ctx.cwd), runtime);
         const row = rows.find((candidate) => candidate.id === id);
         if (!row)
             throw new Error(`未找到推荐 MCP: ${id}`);
+        if (row.source !== "recommended")
+            throw new Error(`MCP ${id} 已是用户配置，无需再次安装`);
         await queueModelMcpInstall(pi, ctx, row, catalog.installPrep.find((candidate) => candidate.id === row.id));
         return;
     }
+    if (verb === "enable-all" || verb === "disable-all") {
+        const enabled = verb === "enable-all";
+        const rows = await mcpManagerRows(ctx.cwd, await readRecommendationState(ctx.cwd), runtime);
+        for (const row of rows) {
+            if (row.source === "user" && row.userEntry)
+                await setUserMcpEnabled(row.userEntry, enabled);
+            else
+                await setRecommendedMcpEnabled(ctx.cwd, row.id, enabled);
+        }
+        ctx.ui.notify(`已批量${enabled ? "开启" : "关闭"}全部 MCP 配置；重启后重新检查运行时可用性`, "info");
+        return;
+    }
     if (verb === "enable" || verb === "disable") {
-        await setRecommendedMcpEnabled(ctx.cwd, id, verb === "enable");
-        ctx.ui.notify(`MCP ${id} 的项目配置已${verb === "enable" ? "开启" : "关闭"}；重启后重新检查安装、信任和工具策略`, "info");
+        const rows = await mcpManagerRows(ctx.cwd, await readRecommendationState(ctx.cwd), runtime);
+        const row = rows.find((candidate) => candidate.id === id);
+        if (!row)
+            throw new Error(`未找到 MCP: ${id}`);
+        if (row.source === "user" && row.userEntry)
+            await setUserMcpEnabled(row.userEntry, verb === "enable");
+        else
+            await setRecommendedMcpEnabled(ctx.cwd, row.id, verb === "enable");
+        ctx.ui.notify(`MCP ${id} 已${verb === "enable" ? "开启" : "关闭"}；重启后重新检查安装、信任和工具策略`, "info");
         return;
     }
     if (!ctx.hasUI || typeof ctx.ui.custom !== "function" || verb === "status") {
-        const rows = await mcpManagerRows(await readRecommendationState(ctx.cwd));
-        ctx.ui.notify(rows.map((row) => `${row.enabled ? "[on]" : "[off]"} ${row.id} — ${row.name}`).join("\n"), "info");
+        const rows = await mcpManagerRows(ctx.cwd, await readRecommendationState(ctx.cwd), runtime);
+        ctx.ui.notify(rows.map((row) => `${row.enabled ? "[on]" : "[off]"} ${row.id} — ${row.name}${row.source === "user" ? "（用户配置）" : ""}`).join("\n"), "info");
         return;
     }
     while (true) {
-        const rows = await mcpManagerRows(await readRecommendationState(ctx.cwd));
+        const rows = await mcpManagerRows(ctx.cwd, await readRecommendationState(ctx.cwd), runtime);
         const action = await openMcpManager(ctx, rows);
         if (action.type === "close")
             return;
+        if (action.type === "toggle-all") {
+            for (const row of rows) {
+                if (row.source === "user" && row.userEntry)
+                    await setUserMcpEnabled(row.userEntry, action.enabled);
+                else
+                    await setRecommendedMcpEnabled(ctx.cwd, row.id, action.enabled);
+            }
+            ctx.ui.notify(`已批量${action.enabled ? "开启" : "关闭"}全部 MCP 配置；重启后重新检查运行时可用性`, "info");
+            continue;
+        }
         const row = rows.find((candidate) => candidate.id === action.id);
         if (!row)
             continue;
         if (action.type === "install") {
+            if (row.source !== "recommended") {
+                ctx.ui.notify(`${row.name} 已是用户配置，无需再次安装`, "info");
+                continue;
+            }
             await queueModelMcpInstall(pi, ctx, row, catalog.installPrep.find((candidate) => candidate.id === row.id));
             return;
         }
         if (action.type === "toggle") {
-            await setRecommendedMcpEnabled(ctx.cwd, row.id, action.enabled);
-            ctx.ui.notify(`${row.name} 的项目配置已${action.enabled ? "开启" : "关闭"}；重启后重新检查运行时可用性`, "info");
+            if (row.source === "user" && row.userEntry)
+                await setUserMcpEnabled(row.userEntry, action.enabled);
+            else
+                await setRecommendedMcpEnabled(ctx.cwd, row.id, action.enabled);
+            ctx.ui.notify(`${row.name} 已${action.enabled ? "开启" : "关闭"}；重启后重新检查运行时可用性`, "info");
         }
     }
 }
@@ -469,8 +634,8 @@ async function showSkillManager(pi, args, ctx) {
     const action = args.trim().split(/\s+/).filter(Boolean);
     const verb = action[0];
     const id = action[1];
-    if (verb && !["status", "enable", "disable", "install"].includes(verb)) {
-        throw new Error("Usage: /skills [status|enable <id>|disable <id>|install <id>]");
+    if (verb && !["status", "enable", "disable", "enable-all", "disable-all", "install"].includes(verb)) {
+        throw new Error("Usage: /skills [status|enable <id>|disable <id>|enable-all|disable-all|install <id>]");
     }
     if ((verb === "enable" || verb === "disable" || verb === "install") && !id) {
         throw new Error(`Usage: /skills ${verb} <id>`);
@@ -482,9 +647,44 @@ async function showSkillManager(pi, args, ctx) {
         await queueModelSkillInstall(pi, ctx, row);
         return;
     }
+    if (verb === "enable-all" || verb === "disable-all") {
+        const enabled = verb === "enable-all";
+        const state = await readRecommendationState(ctx.cwd);
+        const rows = await skillManagerRows(ctx.cwd, state);
+        const managed = rows.filter((row) => row.source === "recommended" && row.installed && !row.blocked);
+        const locals = rows.filter((row) => row.source === "local");
+        const failed = [];
+        for (const row of managed) {
+            try {
+                await setRecommendedSkillEnabled(ctx.cwd, row.id, enabled);
+            }
+            catch {
+                if (enabled)
+                    failed.push(row.name);
+            }
+        }
+        if (locals.length > 0) {
+            await setLocalSkillsEnabled(ctx.cwd, locals.map((row) => row.name), enabled);
+        }
+        ctx.ui.notify(enabled && failed.length > 0
+            ? `已批量启用（${failed.join("、")} 启用失败）。请运行 /reload 重新加载。`
+            : `已批量${enabled ? "启用" : "停用"}可管理的 Skill。请运行 /reload 重新加载。`, enabled && failed.length > 0 ? "warning" : "info");
+        return;
+    }
     if (verb === "enable" || verb === "disable") {
-        await setRecommendedSkillEnabled(ctx.cwd, id, verb === "enable");
-        ctx.ui.notify(`${verb === "enable" ? "已启用" : "已停用"} ${normalizeRecommendedSkillId(id)}。请运行 /reload 重新加载。`, "info");
+        const requested = normalizeRecommendedSkillId(id);
+        const state = await readRecommendationState(ctx.cwd);
+        const rows = await skillManagerRows(ctx.cwd, state);
+        const row = rows.find((candidate) => candidate.id === requested || candidate.name === requested || candidate.id === userSkillId(requested));
+        if (!row)
+            throw new Error(`未找到 Skill: ${id}`);
+        if (row.source === "local") {
+            await setLocalSkillEnabled(ctx.cwd, row.name, verb === "enable");
+        }
+        else {
+            await setRecommendedSkillEnabled(ctx.cwd, row.id, verb === "enable");
+        }
+        ctx.ui.notify(`${verb === "enable" ? "已启用" : "已停用"} ${row.name}。请运行 /reload 重新加载。`, "info");
         return;
     }
     if (!ctx.hasUI || typeof ctx.ui.custom !== "function" || verb === "status") {
@@ -503,6 +703,42 @@ async function showSkillManager(pi, args, ctx) {
         const action = await openSkillManager(ctx, rows);
         if (action.type === "close")
             return;
+        if (action.type === "toggle-all") {
+            const managed = rows.filter((row) => row.source === "recommended" && row.installed && !row.blocked);
+            const locals = rows.filter((row) => row.source === "local");
+            if (action.enabled) {
+                const failed = [];
+                for (const row of managed) {
+                    try {
+                        await setRecommendedSkillEnabled(ctx.cwd, row.id, true);
+                    }
+                    catch {
+                        failed.push(row.name);
+                    }
+                }
+                if (locals.length > 0) {
+                    const ids = locals.map((row) => row.name);
+                    await setLocalSkillsEnabled(ctx.cwd, ids, true);
+                }
+                ctx.ui.notify(failed.length > 0
+                    ? `已启用全部可管理的 Skill（${failed.join("、")} 启用失败：可能未通过来源、许可或依赖预检）。请运行 /reload 重新加载。`
+                    : `已启用全部可管理的 Skill。请运行 /reload 重新加载。`, failed.length > 0 ? "warning" : "info");
+            }
+            else {
+                for (const row of managed) {
+                    try {
+                        await setRecommendedSkillEnabled(ctx.cwd, row.id, false);
+                    }
+                    catch { /* already disabled */ }
+                }
+                if (locals.length > 0) {
+                    const ids = locals.map((row) => row.name);
+                    await setLocalSkillsEnabled(ctx.cwd, ids, false);
+                }
+                ctx.ui.notify("已停用全部可管理的 Skill。请运行 /reload 重新加载。", "info");
+            }
+            continue;
+        }
         const row = rows.find((candidate) => candidate.id === action.id);
         if (!row)
             continue;
@@ -511,8 +747,14 @@ async function showSkillManager(pi, args, ctx) {
             return;
         }
         if (action.type === "toggle") {
-            await setRecommendedSkillEnabled(ctx.cwd, row.id, action.enabled);
-            ctx.ui.notify(`已${action.enabled ? "启用" : "停用"} ${row.name}。请运行 /reload 重新加载。`, "info");
+            if (row.source === "local") {
+                await setLocalSkillEnabled(ctx.cwd, row.name, action.enabled);
+                ctx.ui.notify(`已${action.enabled ? "启用" : "停用"}本地 Skill ${row.name}。请运行 /reload 重新加载。`, "info");
+            }
+            else {
+                await setRecommendedSkillEnabled(ctx.cwd, row.id, action.enabled);
+                ctx.ui.notify(`已${action.enabled ? "启用" : "停用"} ${row.name}。请运行 /reload 重新加载。`, "info");
+            }
         }
     }
 }
@@ -614,13 +856,26 @@ const WORKFLOW_RUNNERS = {
 export default function psyclawExtension(pi) {
     const developerCommands = process.env.PSYCLAW_DEVELOPER_COMMANDS === "1";
     const legacyTestApi = typeof pi.registerTool !== "function";
+    const runtimeMcps = new RuntimeMcpRegistry();
     if (!legacyTestApi && typeof pi.on === "function")
         pi.on("resources_discover", async (event, ctx) => {
             const enabled = await enabledRecommendedSkillPaths(event.cwd);
             for (const warning of enabled.warnings)
                 ctx.ui.notify(`PsyClaw Skill: ${warning}`, "warning");
-            return { skillPaths: enabled.paths };
+            const local = await enabledLocalSkillPaths(event.cwd, {
+                excludedNames: [...coreSkillNames(), ...await skillNamesInPaths(enabled.paths)],
+            });
+            for (const warning of local.warnings)
+                ctx.ui.notify(`PsyClaw Skill: ${warning}`, "warning");
+            // Return only existing Skill directories. Same-name local/core candidates
+            // are resolved before Pi sees them, so harmless collisions stay silent.
+            return {
+                skillPaths: [...enabled.paths, ...local.paths],
+                promptPaths: await enabledLocalPromptPaths(event.cwd),
+            };
         });
+    if (!legacyTestApi && typeof pi.on === "function")
+        pi.on("session_shutdown", () => runtimeMcps.close());
     pi.registerCommand("init", {
         description: "初始化可追溯的研究项目",
         handler: async (args, ctx) => {
@@ -642,18 +897,47 @@ export default function psyclawExtension(pi) {
     });
     if (!legacyTestApi)
         pi.registerCommand("run", {
-            description: "在 /init 后启动受控研究流程",
+            description: "启动受控研究流程，可用 --skills a,b 选择本次优化 Skill",
             handler: async (args, ctx) => {
                 try {
-                    const project = await readProject(ctx.cwd);
-                    const objective = args.trim() || project.goal;
-                    await activateControlledRun(ctx.cwd, project.id, objective);
-                    pi.appendEntry("psyclaw:controlled-run", { projectId: project.id, objective, activatedAt: new Date().toISOString() });
-                    pi.sendUserMessage(controlledRunRequest(objective), ctx.isIdle() ? {} : { deliverAs: "followUp" });
-                    ctx.ui.notify("受控研究流程已启动。分析完成后会先询问是否撰写论文；不会直接进入 DOCX 导出。", "info");
+                    const parsed = parseRunArgs(args);
+                    let project;
+                    try {
+                        project = await readProject(ctx.cwd);
+                    }
+                    catch (error) {
+                        // No `.psyclaw/project.json` (or it is corrupt): fall back to the
+                        // compliant analysis documents when present, so a project prepared
+                        // outside the /init flow can be analyzed directly.
+                        const { bootstrapProjectFromAnalysisDocs } = await import("../../project/bootstrap.js");
+                        try {
+                            project = await bootstrapProjectFromAnalysisDocs(ctx.cwd);
+                        }
+                        catch (bootstrapError) {
+                            ctx.ui.notify(bootstrapError instanceof Error ? bootstrapError.message : String(bootstrapError), "warning");
+                            return;
+                        }
+                        ctx.ui.notify("检测到合规的分析文档，已自动补齐研究项目记录并启动受控流程。", "info");
+                    }
+                    const available = await selectableRunSkills(ctx.cwd);
+                    let requestedSkills = parsed.requestedSkills;
+                    if (requestedSkills === undefined && ctx.hasUI && typeof ctx.ui.input === "function") {
+                        const answer = await ctx.ui.input("选择本次 Run 使用的 Skill（逗号分隔，可留空）", available.map((skill) => skill.name).join(", "));
+                        if (answer === undefined) {
+                            ctx.ui.notify("已取消启动受控研究流程", "info");
+                            return;
+                        }
+                        requestedSkills = answer.split(",").map((item) => item.trim()).filter(Boolean);
+                    }
+                    const selectedSkills = resolveRunSkills(requestedSkills ?? [], available);
+                    const objective = parsed.objective || project.goal;
+                    await activateControlledRun(ctx.cwd, project.id, objective, selectedSkills);
+                    pi.appendEntry("psyclaw:controlled-run", { projectId: project.id, objective, selectedSkills, activatedAt: new Date().toISOString() });
+                    pi.sendUserMessage(controlledRunRequest(objective, selectedSkills), ctx.isIdle() ? {} : { deliverAs: "followUp" });
+                    ctx.ui.notify(`受控研究流程已启动${selectedSkills.length > 0 ? `；本次使用 Skill：${selectedSkills.join(", ")}` : "；使用默认 Skill"}。分析完成后会先询问是否撰写论文。`, "info");
                 }
-                catch {
-                    ctx.ui.notify("请先使用 /init 初始化研究项目；未运行 /init 和 /run 时保持普通对话模式。", "warning");
+                catch (error) {
+                    await notifyError(ctx, error);
                 }
             },
         });
@@ -799,12 +1083,24 @@ export default function psyclawExtension(pi) {
                 }
             },
         });
+    if (!legacyTestApi)
+        pi.registerCommand("skill", {
+            description: "调用任意已加载 Skill（/skill <name> [任务]）",
+            handler: async (args, ctx) => {
+                const [name, ...rest] = args.trim().split(/\s+/).filter(Boolean);
+                if (!name || !/^[a-z0-9-]+$/.test(name)) {
+                    ctx.ui.notify("Usage: /skill <name> [task]；也可直接使用 /skill:<name>", "info");
+                    return;
+                }
+                pi.sendUserMessage(`/skill:${name}${rest.length ? ` ${rest.join(" ")}` : ""}`, ctx.isIdle() ? {} : { deliverAs: "followUp" });
+            },
+        });
     if (!legacyTestApi)
         pi.registerCommand("mcp", {
             description: "打开 MCP 安装与配置管理页",
             handler: async (args, ctx) => {
                 try {
-                    await showMcpManager(pi, args, ctx);
+                    await showMcpManager(pi, args, ctx, runtimeMcps);
                 }
                 catch (error) {
                     await notifyError(ctx, error);
@@ -831,13 +1127,13 @@ export default function psyclawExtension(pi) {
                         if (kind === "skill")
                             await showSkillManager(pi, "", ctx);
                         else
-                            await showMcpManager(pi, "", ctx);
+                            await showMcpManager(pi, "", ctx, runtimeMcps);
                         return;
                     }
                     if (kind === "skill")
                         await showSkillManager(pi, `install ${id}`, ctx);
                     else
-                        await showMcpManager(pi, `install ${id}`, ctx);
+                        await showMcpManager(pi, `install ${id}`, ctx, runtimeMcps);
                 }
                 catch (error) {
                     await notifyError(ctx, error);
@@ -945,18 +1241,18 @@ export default function psyclawExtension(pi) {
             },
         });
     const traceCommand = {
-        description: "导出脱敏使用路径，供 Langfuse 或 LangSmith 分析",
+        description: "导出包含正文与工具参数的完整使用路径，供 Langfuse 或 LangSmith 分析",
         handler: async (args, ctx) => {
             try {
                 if (args.trim())
-                    throw new Error("Usage: /trace");
+                    throw new Error("Usage: /export");
                 const result = await exportTraces({ root: ctx.cwd });
                 ctx.ui.notify([
                     "使用路径已导出（未上传）",
                     `文件：${result.output}`,
                     `轨迹：${result.traces}`,
                     `步骤：${result.spans}`,
-                    "隐私：不含对话正文、工具参数、原始 ID 或绝对路径",
+                    "包含对话正文、工具参数、原始 ID 与绝对路径，便于排查各环节问题；请勿将导出文件提交到公开仓库。",
                 ].join("\n"), "info");
             }
             catch (error) {
@@ -964,8 +1260,40 @@ export default function psyclawExtension(pi) {
             }
         },
     };
-    pi.registerCommand("trace", traceCommand);
+    pi.registerCommand("export", traceCommand);
     if (typeof pi.registerTool === "function") {
+        pi.registerTool({
+            name: "psyclaw_mcp",
+            label: "MCP tools",
+            description: "List and call tools from MCP servers enabled in .psyclaw/mcp/*.json. Use action=list first, then action=call with the exact server and tool names.",
+            promptSnippet: "Discover and call enabled MCP servers such as MNE through PsyClaw.",
+            parameters: Type.Object({
+                action: Type.Union([Type.Literal("list"), Type.Literal("call")]),
+                server: Type.Optional(Type.String({ description: "Configured MCP server id, for example mne-mcp" })),
+                tool: Type.Optional(Type.String({ description: "Exact MCP tool name returned by action=list" })),
+                input: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            }),
+            executionMode: "sequential",
+            async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+                try {
+                    if (params.action === "list") {
+                        const servers = await runtimeMcps.list(ctx.cwd, params.server);
+                        return { content: [{ type: "text", text: JSON.stringify({ servers }, null, 2) }], details: { action: "list", servers: servers.length } };
+                    }
+                    if (!params.server || !params.tool)
+                        throw new Error("server and tool are required for action=call");
+                    const result = await runtimeMcps.call(ctx.cwd, params.server, params.tool, params.input ?? {});
+                    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: { action: "call", server: params.server, tool: params.tool } };
+                }
+                catch (error) {
+                    return {
+                        content: [{ type: "text", text: `MCP call failed: ${error instanceof Error ? error.message : String(error)}` }],
+                        details: { action: params.action, status: "failed" },
+                        isError: true,
+                    };
+                }
+            },
+        });
         pi.registerTool({
             name: "psyclaw_skill",
             label: "Research skill",