ccdesk 0.1.0 → 0.2.0

package/dist/server/scan/inventory.js

@@ -2,22 +2,25 @@ import { basename, dirname, join, relative } from "node:path";
 import { HIGHEST_FIRST } from "../../shared/scopes.js";
 import {} from "../../shared/types.js";
 import {} from "./env.js";
-import { isDir, isFile, isRecord, isWithin, listDir, parseFrontmatter, readJsonObject, readTextFile, resolvedPath, stringField, toStringList, } from "./files.js";
+import { isDir, isFile, isRecord, isWithin, listDir, parseFrontmatter, readJsonObject, readTextFile, redactSecrets, resolvedPath, shownUrl, stringField, toStringList, } from "./files.js";
 import { ancestorsRootFirst } from "./instructions.js";
 import { readMcpServers } from "./mcp.js";
-import { manifestCommandMap, manifestConfigs, manifestPaths, readPlugins } from "./plugins.js";
+import { manifestCommandMap, manifestConfigs, manifestPaths, pluginNamespace, readPlugins, } from "./plugins.js";
 import { effectiveSettings } from "./settings.js";
 function isTrue(value) {
     return value === true || (typeof value === "string" && /^(true|yes|on|1)$/i.test(value));
 }
-/** A `.md` file as an agent, command or output style. */
-async function readEntry(path, name, scope, plugin) {
-    const file = await readTextFile(path);
+/**
+ * A `.md` file as an agent, command or output style. `fileName` is its name from its path, which a
+ * frontmatter `name` replaces, except for a command (docs: skills#how-a-skill-gets-its-command-name).
+ */
+async function readEntry(env, path, fileName, scope, { plugin, isCommand = false } = {}) {
+    const file = await readTextFile(env, path);
     if (!file)
         return null;
     const { data } = parseFrontmatter(file.text);
     const entry = {
-        name: stringField(data, "name") || name,
+        name: (!isCommand && stringField(data, "name")) || fileName,
         description: stringField(data, "description"),
         path,
         scope,
@@ -37,7 +40,7 @@ async function readEntry(path, name, scope, plugin) {
  * `*.md` files in a folder and its subfolders. A file in a subfolder is named by its path, joined
  * with `separator`: commands use ":" (`frontend/component.md` is `/frontend:component`).
  */
-async function readFileEntries(dir, scope, { plugin, separator = "/" } = {}, base = dir, depth = 0) {
+async function readFileEntries(env, dir, scope, { plugin, separator = "/" } = {}, base = dir, depth = 0) {
     const out = [];
     for (const name of await listDir(dir)) {
         if (name.startsWith("."))
@@ -45,35 +48,42 @@ async function readFileEntries(dir, scope, { plugin, separator = "/" } = {}, bas
         const path = join(dir, name);
         if (await isDir(path)) {
             if (depth < 4)
-                out.push(...(await readFileEntries(path, scope, { plugin, separator }, base, depth + 1)));
+                out.push(...(await readFileEntries(env, path, scope, { plugin, separator }, base, depth + 1)));
             continue;
         }
         if (!name.endsWith(".md"))
             continue;
-        const fallback = relative(base, path).replace(/\.md$/, "").split(/[/\\]/).join(separator);
-        const entry = await readEntry(path, fallback, scope, plugin);
+        const fileName = relative(base, path).replace(/\.md$/, "").split(/[/\\]/).join(separator);
+        // Commands are the entries joined with ":".
+        const entry = await readEntry(env, path, fileName, scope, {
+            plugin,
+            isCommand: separator === ":",
+        });
         if (entry)
             out.push(entry);
     }
     return out;
 }
 /** Files or folders of `.md` files. */
-async function readPaths(paths, scope, options) {
+async function readPaths(env, paths, scope, options) {
     const out = [];
     for (const path of paths) {
         if (await isDir(path))
-            out.push(...(await readFileEntries(path, scope, options)));
+            out.push(...(await readFileEntries(env, path, scope, options)));
         else if (path.endsWith(".md")) {
-            const entry = await readEntry(path, basename(path, ".md"), scope, options.plugin);
+            const entry = await readEntry(env, path, basename(path, ".md"), scope, {
+                plugin: options.plugin,
+                isCommand: options.separator === ":",
+            });
             if (entry)
                 out.push(entry);
         }
     }
     return out;
 }
-export async function readSkill(folder, scope, plugin) {
+export async function readSkill(env, folder, scope, plugin) {
     const path = join(folder, "SKILL.md");
-    const file = await readTextFile(path);
+    const file = await readTextFile(env, path);
     if (!file)
         return null;
     const { data, body } = parseFrontmatter(file.text);
@@ -105,40 +115,51 @@ export async function readSkill(folder, scope, plugin) {
     return entry;
 }
 /** `<name>/SKILL.md` folders, or one folder holding SKILL.md itself. */
-async function readSkills(dir, scope, plugin) {
+async function readSkills(env, dir, scope, plugin) {
     if (plugin && (await isFile(join(dir, "SKILL.md")))) {
-        const skill = await readSkill(dir, scope, plugin);
+        const skill = await readSkill(env, dir, scope, plugin);
         return skill ? [skill] : [];
     }
     const out = [];
     for (const name of await listDir(dir)) {
         if (name.startsWith(".") || (scope === "user" && name === "synced"))
             continue;
-        const skill = await readSkill(join(dir, name), scope, plugin);
+        const skill = await readSkill(env, join(dir, name), scope, plugin);
         if (skill)
             out.push(skill);
     }
     return out;
 }
 /** A plugin's skills, agents, commands and output styles, from its folders and its manifest. */
-async function pluginEntries(plugin) {
+async function pluginEntries(env, plugin) {
     const root = plugin.installPath;
     const options = { plugin: plugin.id };
     // `skills` adds to the default folder; the other keys replace theirs (docs: plugins-reference).
-    const extraSkills = await manifestPaths(plugin, "skills");
+    const extraSkills = await manifestPaths(env, plugin, "skills");
     const skillDirs = [join(root, "skills"), ...(extraSkills ?? [])];
     const rootSkill = extraSkills === null && !(await isDir(join(root, "skills")));
-    const skills = rootSkill ? await readSkills(root, "plugin", plugin.id) : [];
+    const namespace = await pluginNamespace(env, plugin);
+    const skills = [];
+    if (rootSkill)
+        for (const skill of await readSkills(env, root, "plugin", plugin.id)) {
+            // Without a name, a root SKILL.md is named after the plugin (docs: skills#how-a-skill-gets-its-command-name).
+            if (skill.folder === root && !stringField(parseFrontmatter(skill.text).data, "name"))
+                skill.name = namespace;
+            skills.push(skill);
+        }
     for (const dir of skillDirs)
-        skills.push(...(await readSkills(dir, "plugin", plugin.id)));
-    const listed = async (key, folder, separator = "/") => readPaths((await manifestPaths(plugin, key)) ?? [join(root, folder)], "plugin", {
+        skills.push(...(await readSkills(env, dir, "plugin", plugin.id)));
+    const listed = async (key, folder, separator = "/") => readPaths(env, (await manifestPaths(env, plugin, key)) ?? [join(root, folder)], "plugin", {
         ...options,
         separator,
     });
     const commands = await listed("commands", "commands", ":");
-    for (const c of await manifestCommandMap(plugin))
+    for (const c of await manifestCommandMap(env, plugin))
         commands.push(c.text === null
-            ? ((await readEntry(c.path, c.name, "plugin", plugin.id)) ?? {
+            ? ((await readEntry(env, c.path, c.name, "plugin", {
+                plugin: plugin.id,
+                isCommand: true,
+            })) ?? {
                 name: c.name,
                 description: c.description,
                 path: c.path,
@@ -154,14 +175,18 @@ async function pluginEntries(plugin) {
                 plugin: plugin.id,
                 text: c.text,
             });
+    // A plugin's skills and commands are called as plugin-name:name; a name that already has the
+    // prefix keeps it once (docs: skills#how-a-skill-gets-its-command-name).
+    for (const entry of [...skills, ...commands])
+        entry.id = entry.name.startsWith(`${namespace}:`) ? entry.name : `${namespace}:${entry.name}`;
     // A plugin subagent is named with the plugin and its subfolders (docs: sub-agents#choose-the-subagent-scope).
     const agents = [];
-    for (const path of (await manifestPaths(plugin, "agents")) ?? [join(root, "agents")]) {
+    for (const path of (await manifestPaths(env, plugin, "agents")) ?? [join(root, "agents")]) {
         const folder = (await isDir(path)) ? path : null;
-        for (const agent of await readPaths([path], "plugin", options)) {
+        for (const agent of await readPaths(env, [path], "plugin", options)) {
             const subfolders = folder ? relative(folder, dirname(agent.path)).split(/[/\\]/) : [];
             const own = agent.name.split("/").at(-1) ?? agent.name;
-            agent.id = [plugin.id.split("@")[0], ...subfolders.filter(Boolean), own].join(":");
+            agent.id = [namespace, ...subfolders.filter(Boolean), own].join(":");
             agents.push(agent);
         }
     }
@@ -183,9 +208,26 @@ function projectFolders(env, projectDir, gitRoot, sub) {
         .map((dir) => join(dir, ".claude", sub))
         .filter((dir) => dir !== join(env.claudeDir, sub));
 }
+/**
+ * What Claude Code requires of a subagent file; it skips one that falls short, and treats one
+ * without a name as documentation (docs: sub-agents#subagent-files-claude-code-skips).
+ */
+export function agentProblems(text) {
+    const { data } = parseFrontmatter(text);
+    const name = stringField(data, "name");
+    const problems = [];
+    if (!name)
+        problems.push("The frontmatter needs a name.");
+    else if (name.length > 256 || name.includes(":") || name.startsWith("-"))
+        problems.push("A name has at most 256 characters, no ':' and does not start with '-'.");
+    if (!stringField(data, "description"))
+        problems.push("The frontmatter needs a description: when Claude should use this agent.");
+    return problems;
+}
 /**
  * Subagents by priority: managed, then project folders closest to the start directory first, then
  * yours. A name defined again lower down is marked as shadowed (docs: sub-agents#choose-the-subagent-scope).
+ * A file Claude Code skips takes no part in that.
  */
 async function readAgents(env, projectDir, gitRoot) {
     const sources = [
@@ -198,7 +240,13 @@ async function readAgents(env, projectDir, gitRoot) {
     const agents = [];
     const winners = new Map();
     for (const [dir, scope] of sources)
-        for (const agent of await readFileEntries(dir, scope)) {
+        for (const agent of await readFileEntries(env, dir, scope)) {
+            const [problem] = agentProblems(agent.text);
+            if (problem) {
+                agent.skipped = problem;
+                agents.push(agent);
+                continue;
+            }
             const winner = winners.get(agent.name);
             if (winner)
                 agent.shadowedBy = winner.path;
@@ -208,6 +256,24 @@ async function readAgents(env, projectDir, gitRoot) {
         }
     return agents;
 }
+/**
+ * Output styles from the managed folder, every project folder from the start directory up to the
+ * repository root (the closest wins) and yours (docs: output-styles#create-a-custom-output-style).
+ * The docs order only the project folders; managed, project, then yours follows subagents.
+ */
+async function readOutputStyles(env, projectDir, gitRoot) {
+    const sources = [
+        [join(env.managedDir, ".claude", "output-styles"), "managed"],
+        ...projectFolders(env, projectDir, gitRoot, "output-styles")
+            .reverse()
+            .map((dir) => [dir, "project"]),
+        [join(env.claudeDir, "output-styles"), "user"],
+    ];
+    const styles = [];
+    for (const [dir, scope] of sources)
+        styles.push(...(await readFileEntries(env, dir, scope)));
+    return styles;
+}
 /**
  * Applies skillOverrides to your skills and command files; plugin skills are not affected
  * (docs: skills#override-skill-visibility-from-settings).
@@ -230,13 +296,13 @@ export async function readInventory(input) {
     const { env, projectDir, gitRoot, layers } = input;
     const plugins = await readPlugins(env, layers, projectDir, gitRoot);
     const active = plugins.filter((p) => p.enabled);
-    const fromPlugins = await Promise.all(active.map(pluginEntries));
+    const fromPlugins = await Promise.all(active.map((plugin) => pluginEntries(env, plugin)));
     const projectClaude = join(projectDir, ".claude");
     const hasProjectDir = projectClaude !== env.claudeDir;
     const files = async (sub, separator = "/") => [
-        ...(await readFileEntries(join(env.claudeDir, sub), "user", { separator })),
+        ...(await readFileEntries(env, join(env.claudeDir, sub), "user", { separator })),
         ...(hasProjectDir
-            ? await readFileEntries(join(projectClaude, sub), "project", { separator })
+            ? await readFileEntries(env, join(projectClaude, sub), "project", { separator })
             : []),
     ];
     // Project skills come from the start directory and every parent up to the repository root.
@@ -253,21 +319,34 @@ export async function readInventory(input) {
     ];
     const skills = [];
     const seenFolders = new Set();
+    // The same name in two of managed, yours and the project runs the first, in that order
+    // (docs: skills#resolve-skills-that-share-a-name).
+    const winners = new Map();
     for (const [dir, scope] of skillDirs) {
-        for (const skill of await readSkills(dir, scope)) {
+        for (const skill of await readSkills(env, dir, scope)) {
             // A folder that several locations link to loads once.
             const real = skill.realPath ?? skill.folder ?? skill.path;
             if (seenFolders.has(real))
                 continue;
             seenFolders.add(real);
+            const winner = winners.get(skill.name);
+            if (winner && winner.scope !== skill.scope)
+                skill.shadowedBy = winner.path;
+            else if (!winner)
+                winners.set(skill.name, skill);
             skills.push(skill);
         }
     }
     // A command file is a skill too: one with disable-model-invocation is not listed to Claude.
     const commands = await files("commands", ":");
-    for (const command of commands)
+    // A skill of the same name runs instead of it (docs: skills#resolve-skills-that-share-a-name).
+    for (const command of commands) {
         if (isTrue(parseFrontmatter(command.text).data["disable-model-invocation"]))
             command.listed = false;
+        const skill = winners.get(command.name);
+        if (skill)
+            command.shadowedBy = skill.path;
+    }
     const overrides = effectiveSettings(layers).find((s) => s.key === "skillOverrides")?.value;
     applySkillOverrides([...skills, ...commands], overrides);
     return {
@@ -278,15 +357,15 @@ export async function readInventory(input) {
         skills: [...skills, ...fromPlugins.flatMap((p) => p.skills)],
         commands: [...commands, ...fromPlugins.flatMap((p) => p.commands)],
         outputStyles: [
-            ...(await files("output-styles")),
+            ...(await readOutputStyles(env, projectDir, gitRoot)),
             ...fromPlugins.flatMap((p) => p.outputStyles),
         ],
-        hooks: await readHooks(layers, active),
+        hooks: await readHooks(env, layers, active, input.trust, input.profile),
         mcpServers: await readMcpServers(input, active),
         plugins,
     };
 }
-async function readHooks(layers, plugins) {
+async function readHooks(env, layers, plugins, trust, profile) {
     const out = [];
     for (const layer of layers) {
         if (layer.data)
@@ -294,10 +373,10 @@ async function readHooks(layers, plugins) {
     }
     for (const plugin of plugins) {
         const path = join(plugin.installPath, "hooks", "hooks.json");
-        const file = await readJsonObject(path);
+        const file = await readJsonObject(env, path);
         if (file.ok)
             out.push(...hooksFrom(file.data.hooks, "plugin", path, plugin));
-        for (const part of await manifestConfigs(plugin, "hooks"))
+        for (const part of await manifestConfigs(env, plugin, "hooks"))
             out.push(...hooksFrom(part.value, "plugin", part.path, plugin));
     }
     // docs: hooks#disable-or-remove-hooks, settings-reference#allowmanagedhooksonly
@@ -309,6 +388,11 @@ async function readHooks(layers, plugins) {
         .find((l) => typeof l.data?.disableAllHooks === "boolean")?.data?.disableAllHooks === true;
     const managedOnly = managed?.allowManagedHooksOnly === true;
     const forcedByManaged = new Set(plugins.filter((p) => p.enabledIn === "managed").map((p) => p.id));
+    // An interactive session holds back hooks from every settings file, managed and yours included,
+    // until the folder or a parent covering it is trusted; -p and the SDK do not (docs:
+    // hooks#workspace-trust, permissions#what-runs-before-you-trust-a-folder). The docs say nothing
+    // of plugin hooks, so those are left as they are.
+    const heldBack = profile === "interactive" && !trust.trusted && !trust.inheritedFrom;
     for (const hook of out) {
         const organisation = hook.source === "managed" || (hook.plugin !== undefined && forcedByManaged.has(hook.plugin));
         if (managedOff) {
@@ -323,6 +407,10 @@ async function readHooks(layers, plugins) {
             hook.active = false;
             hook.note = "Managed settings allow only managed hooks (allowManagedHooksOnly)";
         }
+        else if (hook.source !== "plugin" && heldBack) {
+            hook.active = false;
+            hook.note = "Waits until you accept Claude Code's trust dialog for this folder";
+        }
     }
     return out;
 }
@@ -333,19 +421,23 @@ function hooksFrom(config, source, sourcePath, plugin) {
     for (const [event, groups] of Object.entries(config)) {
         if (!Array.isArray(groups))
             continue;
-        for (const group of groups) {
+        for (const [g, group] of groups.entries()) {
             if (!isRecord(group) || !Array.isArray(group.hooks))
                 continue;
-            for (const h of group.hooks) {
+            for (const [index, h] of group.hooks.entries()) {
                 if (!isRecord(h))
                     continue;
                 const entry = {
                     event,
                     type: stringField(h, "type") || "command",
-                    command: stringField(h, "command") || stringField(h, "prompt") || stringField(h, "url"),
+                    command: stringField(h, "command") ||
+                        stringField(h, "prompt") ||
+                        shownUrl(stringField(h, "url")),
                     source,
                     sourcePath,
                     active: true,
+                    at: { group: g, index },
+                    definition: redactSecrets(h),
                 };
                 const matcher = stringField(group, "matcher");
                 if (matcher)

package/dist/server/scan/mcp.js

@@ -1,9 +1,34 @@
 import { join } from "node:path";
 import {} from "../../shared/types.js";
-import {} from "./env.js";
-import { isRecord, readJsonObject, shownUrl, stringField, stringsIn, wildcard } from "./files.js";
+import { isConfigHome } from "./env.js";
+import { isRecord, readJsonObject, redactSecrets, shownUrl, stringField, stringsIn, wildcard, } from "./files.js";
 import { manifestConfigs } from "./plugins.js";
+import serverSchema from "../../shared/mcp-server.schema.json" with { type: "json" };
+import { ajv, schemaErrors } from "../schema.js";
 import { readManagedSettings } from "./settings.js";
+const validateServer = ajv.compile(serverSchema);
+/**
+ * What makes a server definition one Claude Code cannot start: a missing command or url, a type it
+ * does not know, or a field the docs define holding the wrong kind of value (docs: mcp). It checks
+ * the rest when it starts the server.
+ */
+export function serverProblems(definition) {
+    if (!isRecord(definition))
+        return ["A server must be a JSON object."];
+    const type = typeof definition.type === "string" ? definition.type : "";
+    if (type === "sdk")
+        return ['Only an SDK host application can register a "sdk" server; Claude Code skips it here.'];
+    const problems = [];
+    if (type === "" || type === "stdio") {
+        if (typeof definition.command !== "string" || definition.command.trim() === "")
+            problems.push(typeof definition.url === "string"
+                ? 'A server with a url needs a "type", such as "http"; without one it is read as a stdio server.'
+                : 'A stdio server needs a "command".');
+    }
+    else if (typeof definition.url !== "string" || definition.url === "")
+        problems.push(`A ${type} server needs a "url".`);
+    return [...problems, ...schemaErrors(validateServer, definition, "")];
+}
 function define(servers, scope, sourcePath, organisation = false) {
     if (!isRecord(servers))
         return [];
@@ -16,19 +41,25 @@ function define(servers, scope, sourcePath, organisation = false) {
         const command = stringField(c, "command")
             ? [stringField(c, "command"), ...stringsIn(c.args)]
             : null;
+        const definition = redactSecrets(c);
         const server = {
             name,
             scope,
             // An entry without a type is read as stdio, even one with a url (docs: mcp).
             transport: type || "stdio",
-            target: url ? shownUrl(url) : (command?.join(" ") ?? ""),
+            target: url
+                ? shownUrl(url)
+                : command
+                    ? [command[0], ...stringsIn(definition.args)].join(" ")
+                    : "",
             sourcePath,
             status: "active",
+            definition,
         };
-        if (!type && url) {
+        const [problem] = serverProblems(c);
+        if (problem) {
             server.status = "invalid";
-            server.note =
-                'Has a url but no "type", so Claude Code reads it as a stdio server and it fails';
+            server.note = problem;
         }
         // A ${VAR} in an organisation entry means it still has to pass the allowlist.
         const usesVariables = JSON.stringify(c).includes("${");
@@ -88,7 +119,7 @@ function defineManaged(servers, sourcePath) {
     return defined;
 }
 /** Two URLs are one endpoint when they differ only in scheme or host case, a default port or a trailing slash. */
-export function endpoint(d) {
+function endpoint(d) {
     if (d.command)
         return `command:${JSON.stringify(d.command)}`;
     if (!d.url)
@@ -160,17 +191,20 @@ function allowed(list, d) {
  * server is one that is configured and allowed, not one that is known to work.
  */
 export async function readMcpServers(input, plugins) {
-    const { env, projectDir, layers, claudeJson, trust } = input;
+    const { env, projectDir, layers, claudeJson, trust, profile } = input;
     const projects = isRecord(claudeJson?.projects) ? claudeJson.projects : {};
-    const entry = [trust.root, projectDir].map((key) => projects[key]).find(isRecord);
-    const project = entry ?? {};
+    // Local servers live in the entry under the trust key, even from a subdirectory: claude mcp add
+    // --scope local writes there and claude mcp list reads only that entry, ignoring one for the
+    // subdirectory (observed with v2.1.296; the docs do not say).
+    const entry = projects[trust.root];
+    const project = isRecord(entry) ? entry : {};
     const managed = layers.find((l) => l.scope === "managed");
     // Checked as written: the layer has header values hidden, which would hide a ${VAR} in one.
     const managedServers = (await readManagedSettings(env)).data?.managedMcpServers;
     const managedFile = join(env.managedDir, "managed-mcp.json");
-    const managedJson = await readJsonObject(managedFile);
+    const managedJson = await readJsonObject(env, managedFile);
     const mcpJson = join(projectDir, ".mcp.json");
-    const shared = await readJsonObject(mcpJson);
+    const shared = await readJsonObject(env, mcpJson);
     const defined = [
         ...(managedJson.ok ? define(managedJson.data.mcpServers, "managed", managedFile, true) : []),
         ...defineManaged(managedServers, managed?.path ?? ""),
@@ -180,7 +214,7 @@ export async function readMcpServers(input, plugins) {
     ];
     for (const plugin of plugins) {
         const path = join(plugin.installPath, ".mcp.json");
-        const file = await readJsonObject(path);
+        const file = await readJsonObject(env, path);
         // A server name declared later in the same plugin replaces an earlier one.
         const own = new Map();
         const add = (list) => {
@@ -189,7 +223,7 @@ export async function readMcpServers(input, plugins) {
         };
         if (file.ok)
             add(define(file.data.mcpServers ?? file.data, "plugin", path));
-        for (const part of await manifestConfigs(plugin, "mcpServers"))
+        for (const part of await manifestConfigs(env, plugin, "mcpServers"))
             add(define(part.value, "plugin", part.path));
         for (const d of own.values())
             d.server.plugin = plugin.id;
@@ -203,19 +237,29 @@ export async function readMcpServers(input, plugins) {
     const allowList = allowLayers.flatMap((l) => policyEntries(l.data?.allowedMcpServers));
     const disabledHere = stringsIn(project.disabledMcpServers);
     // A cloned repository cannot approve its own servers: project and local approvals count once the
-    // folder is trusted, local ones in your home directory right away (docs: mcp#project-server-approvals-and-workspace-trust).
-    const approvalLayers = layers.filter((l) => (l.scope !== "project" && l.scope !== "local") ||
+    // folder is trusted, local ones in your configuration home right away (docs: mcp#project-server-approvals-and-workspace-trust).
+    // A disabledMcpjsonServers entry in any file rejects the server.
+    const approvalCounts = (scope) => (scope !== "project" && scope !== "local") ||
         trust.trusted ||
-        (l.scope === "local" && projectDir === env.home));
-    const approveAll = approvalLayers.some((l) => l.data?.enableAllProjectMcpServers === true);
-    const approved = new Set([
-        ...approvalLayers.flatMap((l) => stringsIn(l.data?.enabledMcpjsonServers)),
-        ...stringsIn(project.enabledMcpjsonServers),
-    ]);
-    const rejected = new Set([
-        ...layers.flatMap((l) => stringsIn(l.data?.disabledMcpjsonServers)),
-        ...stringsIn(project.disabledMcpjsonServers),
-    ]);
+        (scope === "local" && isConfigHome(env, projectDir));
+    // Your answers to the .mcp.json prompt sit in the project entry: claude mcp list counts an
+    // enableAllProjectMcpServers there, and claude mcp reset-project-choices clears it (v2.1.296).
+    const sources = [
+        ...layers.flatMap((l) => (l.data ? [{ source: l.scope, path: l.path, data: l.data }] : [])),
+        { source: "claude-json", path: env.claudeJson, data: project },
+    ];
+    const answersFor = (name) => sources.flatMap(({ source, path, data }) => {
+        const counts = source === "claude-json" || approvalCounts(source);
+        const out = [];
+        if (data.enableAllProjectMcpServers === true)
+            out.push({ key: "enableAllProjectMcpServers", source, path, counts });
+        if (stringsIn(data.enabledMcpjsonServers).includes(name))
+            out.push({ key: "enabledMcpjsonServers", source, path, counts });
+        if (stringsIn(data.disabledMcpjsonServers).includes(name))
+            out.push({ key: "disabledMcpjsonServers", source, path, counts: true });
+        return out;
+    });
+    const from = (a) => a.source === "claude-json" ? "your answer in ~/.claude.json" : `${a.source} settings`;
     const set = (server, status, note) => {
         server.status = status;
         server.note = note;
@@ -244,10 +288,24 @@ export async function readMcpServers(input, plugins) {
             set(server, "blocked", managedOnly ? "Not in the managed allowedMcpServers" : "Not in allowedMcpServers");
         else if (disabledHere.includes(server.name))
             set(server, "disabled", "Turned off for this project in /mcp");
-        else if (server.scope === "project" && rejected.has(server.name))
-            set(server, "rejected", "Rejected by disabledMcpjsonServers");
-        else if (server.scope === "project" && !approveAll && !approved.has(server.name))
-            set(server, "pending", "Claude Code asks before starting servers from .mcp.json");
+        else if (server.scope === "project") {
+            const answers = answersFor(server.name);
+            if (answers.length > 0)
+                server.approvals = answers;
+            const rejection = answers.find((a) => a.key === "disabledMcpjsonServers");
+            const waiting = answers.find((a) => a.key !== "disabledMcpjsonServers" && !a.counts);
+            const approved = answers.some((a) => a.key !== "disabledMcpjsonServers" && a.counts);
+            if (rejection)
+                set(server, "rejected", `Rejected by disabledMcpjsonServers in ${from(rejection)}`);
+            // claude -p connects them without asking, approved or not (docs: permissions#what-runs-before-you-trust-a-folder).
+            else if (!approved && profile === "print")
+                server.note =
+                    "Not approved, but claude -p connects .mcp.json servers without asking; the SDK does when settingSources includes project";
+            else if (!approved)
+                set(server, "pending", waiting
+                    ? `Claude Code asks before starting it: ${waiting.key} in ${from(waiting)} counts once you trust this folder`
+                    : "Claude Code asks before starting servers from .mcp.json: answer its prompt, or list the server in enabledMcpjsonServers in your user settings");
+        }
         if (server.status === "active" || server.status === "pending")
             enabledEndpoints.set(endpoint(d), d);
     }

package/dist/server/scan/memory.js

@@ -1,23 +1,20 @@
 import { join } from "node:path";
 import {} from "../../shared/types.js";
+import {} from "./env.js";
 import { isDir, listDir, parseFrontmatter, readTextFile, revisionOf, shortHash, stringField, } from "./files.js";
 const INDEX_FILE = "MEMORY.md";
 /** Claude Code reads only this much of MEMORY.md at session start (docs: memory#auto-memory). */
 const INDEX_LINE_LIMIT = 200;
 const INDEX_BYTE_LIMIT = 25 * 1024;
 const TYPES = ["user", "feedback", "project", "reference"];
-/** Claude Code names a project's store after its path with every non-alphanumeric character as "-". */
-export function storeDirName(projectPath) {
-    return projectPath.replace(/[^a-zA-Z0-9]/g, "-");
-}
-export async function readMemoryStore(dir, projectPath) {
+export async function readMemoryStore(env, dir, projectPath) {
     if (!(await isDir(dir)))
         return null;
-    const indexFile = await readTextFile(join(dir, INDEX_FILE));
+    const indexFile = await readTextFile(env, join(dir, INDEX_FILE));
     const files = (await listDir(dir)).filter((f) => f.endsWith(".md") && f !== INDEX_FILE);
     const memories = [];
     for (const file of files) {
-        const text = await readTextFile(join(dir, file));
+        const text = await readTextFile(env, join(dir, file));
         if (!text)
             continue;
         const { data, body } = parseFrontmatter(text.text);
@@ -60,7 +57,8 @@ export async function readMemoryStore(dir, projectPath) {
     };
 }
 function summarizeIndex(file, files) {
-    const lines = file.text.split("\n");
+    // A file's last newline ends its last line; it does not start another one.
+    const lines = file.text.replace(/\n$/, "").split("\n");
     let loadedLines = 0;
     let bytes = 0;
     for (const line of lines) {
@@ -83,7 +81,8 @@ export function deadLinks(line, files) {
         .map((m) => m[1] ?? "")
         .filter((f) => !files.includes(f));
 }
-function indexMentions(index, file) {
+/** Whether MEMORY.md text points at a memory file, as a Markdown link or a [[name]] link. */
+export function indexMentions(index, file) {
     return index.includes(`(${file})`) || index.includes(`[[${file.replace(/\.md$/, "")}]]`);
 }
 function wikiLinks(body) {