ccdesk 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.2.2](https://github.com/ayagmar/ccdesk/compare/v0.2.1...v0.2.2) (2026-10-12)
+
+### Bug Fixes
+
+* **agents:** refuse agent text with values its review would hide ([3a9b39f](https://github.com/ayagmar/ccdesk/commit/3a9b39f2634cf4a10a9fc9a7ba7c627dddebd9da))
+* **compare:** ignore key order when comparing settings ([db71cde](https://github.com/ayagmar/ccdesk/commit/db71cde8c19c4bae292e5f41cd8d8c0cf7c578e4))
+* **context:** count a linked rule imported by its target's path once ([63830ef](https://github.com/ayagmar/ccdesk/commit/63830ef9096c2a86005cb60bad3d1c872921cdc1))
+* **context:** count a rule in a linked folder once when it is also imported ([168039b](https://github.com/ayagmar/ccdesk/commit/168039b738524b1d72f5e48edfcb51bea069a506))
+* **context:** prefer the real path the scan recorded when deduplicating ([d5a3e75](https://github.com/ayagmar/ccdesk/commit/d5a3e7566668156de9a3739b9fa51a39301cf697))
+* **env:** make a relative CLAUDE_CONFIG_DIR absolute ([2939488](https://github.com/ayagmar/ccdesk/commit/2939488c5ded1869367ca769218f17be8880fcd4))
+* **hooks:** refuse a replacement hook with hidden header values ([c40e7b4](https://github.com/ayagmar/ccdesk/commit/c40e7b4dfeda44fe104ad24cbd790a846da31266))
+* **mcp:** name the chosen profile in the claude commands ccdesk shows ([4d99fbd](https://github.com/ayagmar/ccdesk/commit/4d99fbd37087fa0a6332bc997975efb510d123b5))
+* **mcp:** run claude with the profile chosen by --config-dir ([02c6af0](https://github.com/ayagmar/ccdesk/commit/02c6af0bd56235874dd1a46dd1a3aaf124f299b8))
+* **path-test:** apply startup's rules to a subfolder's linked rules ([49d426c](https://github.com/ayagmar/ccdesk/commit/49d426c07beb5ce8e6538c2091b5e3c989d356e1))
+* **path-test:** keep AGENTS.md out when a subfolder's CLAUDE.md is skipped ([c05ed89](https://github.com/ayagmar/ccdesk/commit/c05ed89f04db3a83b1dad2e35b803cbb4af2e4a3))
+* **path-test:** match a linked rule's target against excludes only as startup does ([dfb6a79](https://github.com/ayagmar/ccdesk/commit/dfb6a79ae70c7eb4c94f4905c76b78f081c8afce))
+* **path-test:** skip subfolder instructions and rules over 4 MiB ([3696d74](https://github.com/ayagmar/ccdesk/commit/3696d74ec070dda64184b100b9eecef181e52884))
+* **scan:** cite the docs section on MCP rules with parentheses ([901c372](https://github.com/ayagmar/ccdesk/commit/901c3729ed4089bdfd5dd19a6265a5995aae1458))
+* **scan:** treat a name starting with two dots as inside its folder ([af6b025](https://github.com/ayagmar/ccdesk/commit/af6b02549e55a24394197da08326412bb1890059))
+* **settings:** refuse hook events Claude Code does not know ([b6561e6](https://github.com/ayagmar/ccdesk/commit/b6561e6f9b5a86a9fa27b3138cb570f493edb0d5))
+* **usage:** do not start a count for a page that already left ([4984a58](https://github.com/ayagmar/ccdesk/commit/4984a585d6a6ccd3914f2e06b9f274bd4b66eb21))
+* **watch:** answer a wait whose watcher closed while it was starting ([5c63129](https://github.com/ayagmar/ccdesk/commit/5c63129bdb60d9bc5f6d13a7665e4f273dcfb406))
+* **watch:** answer waiting pages when the watcher closes ([ad1c5ea](https://github.com/ayagmar/ccdesk/commit/ad1c5ea1080362858755e5f2c09e4bf19a3682e2))
+* **watch:** refresh when a file inside an installed plugin changes ([a09a99e](https://github.com/ayagmar/ccdesk/commit/a09a99e38c37c765c5117138324d50174ad7b142))
+* **watch:** refresh when a missing import is created ([279b033](https://github.com/ayagmar/ccdesk/commit/279b03353f414ed9faeaf0a86450c49da56aea1a))
+* **watch:** refresh when a missing import's folder appears later ([91f6444](https://github.com/ayagmar/ccdesk/commit/91f644452c3975dd09b2f1fbb86b2c96cf5da561))
+* **watch:** watch ~/.claude/plugins only for the install list ([382b6b0](https://github.com/ayagmar/ccdesk/commit/382b6b0990c82f71dab37cfd8840bd1aec42c47e))
+* **watch:** watch only the plugin files the scan reads ([8d12adc](https://github.com/ayagmar/ccdesk/commit/8d12adcfa0cdf74097273516d04130a99cffe578))
+
 ## [0.2.1](https://github.com/ayagmar/ccdesk/compare/v0.2.0...v0.2.1) (2026-10-12)
 
 ### Features

package/README.md

@@ -8,6 +8,7 @@
 [![npm](https://img.shields.io/npm/v/ccdesk?style=flat-square&color=141414)](https://www.npmjs.com/package/ccdesk)
 [![CI](https://img.shields.io/github/actions/workflow/status/ayagmar/ccdesk/ci.yml?branch=master&style=flat-square&label=ci)](https://github.com/ayagmar/ccdesk/actions/workflows/ci.yml)
 [![node](https://img.shields.io/node/v/ccdesk?style=flat-square&color=141414)](https://github.com/ayagmar/ccdesk/blob/master/package.json)
+[![Ask DeepWiki](https://img.shields.io/badge/Ask-DeepWiki-blue)](https://deepwiki.com/ayagmar/ccdesk)
 [![license](https://img.shields.io/github/license/ayagmar/ccdesk?style=flat-square&color=141414)](https://github.com/ayagmar/ccdesk/blob/master/LICENSE)
 
 See and change everything Claude Code loads on your machine: instruction files, settings, permissions, hooks, MCP servers, subagents, skills, plugins and auto memory.
@@ -16,7 +17,7 @@ See and change everything Claude Code loads on your machine: instruction files,
 npx ccdesk
 ```
 
-Each piece lives in its own file, at one of six scopes: managed, user, project, local, auto memory or a plugin. ccdesk opens in your browser on the directory you ran it from, lists everything that applies there in the order Claude Code loads it, and names the file behind each piece. When something is wrong, change it on the same page: you review the diff first, and every edit has a backup and an undo. It is not a session viewer or a usage dashboard.
+Each piece lives in its own file, at one of six scopes: managed, user, project, local, auto memory or a plugin. ccdesk opens in your browser on the directory you ran it from, lists everything that applies there in the order Claude Code loads it, and names the file behind each piece. When something is wrong, change it on the same page: you review the diff first, and every file ccdesk writes is backed up and can be undone. It is not a session viewer or a usage dashboard.
 
 **Docs:** [ayagmar.github.io/ccdesk](https://ayagmar.github.io/ccdesk/)
 
@@ -74,7 +75,7 @@ Each piece lives in its own file, at one of six scopes: managed, user, project,
 - The old file is backed up to `~/.claude/backups/ccdesk/` first. Undo is one click, and **Recent changes** can restore any earlier edit.
 - A settings file that is a symlink, such as one in a dotfiles repository, is written through and stays a link.
 - A file with other hard links is not saved: replacing it would split it from its other names. Edit it in your editor.
-- ccdesk never writes `~/.claude.json`. User and local MCP server changes go through Claude Code's own `claude mcp` command, so they need `claude` on your PATH.
+- ccdesk never writes `~/.claude.json`. User and local MCP server changes go through Claude Code's own `claude mcp` command, so they need `claude` on your PATH. ccdesk keeps no backup of these and cannot undo them; **Recent changes** lists each one with the commands that reverse it.
 
 Details: [Recent changes, backups and undo](https://ayagmar.github.io/ccdesk/recent-changes/)
 
@@ -104,7 +105,7 @@ npx ccdesk [options]
   -h, --help            Show this help
 ```
 
-ccdesk reads `~/.claude` and `~/.claude.json`, or `$CLAUDE_CONFIG_DIR` when it is set, as Claude Code does. To look at another profile without exporting the variable, pass `--config-dir <path>`. Edits made in another editor or by Claude show up within a second. Requires Node.js 22.19 or newer. See [Platform notes](https://ayagmar.github.io/ccdesk/platforms/) for Windows, macOS and WSL.
+ccdesk reads `~/.claude` and `~/.claude.json`, or `$CLAUDE_CONFIG_DIR` when it is set, as Claude Code does. To look at another profile without exporting the variable, pass `--config-dir <path>`. Edits made in another editor or by Claude show up within a second. Changes to `~/.claude.json`, such as trust decisions and MCP approvals, show up when you return to the tab. Requires Node.js 22.19 or newer. See [Platform notes](https://ayagmar.github.io/ccdesk/platforms/) for Windows, macOS and WSL.
 
 ## Privacy and safety
 

package/dist/server/agent-edit.js

@@ -40,7 +40,12 @@ async function plan(env, edit) {
     // from it would lose them; it can still be deleted, as a whole.
     if (edit.text !== null && before !== raw)
         throw new RefusedError(`${path} has env, header or URL values ccdesk does not show; edit it in your editor instead.`);
-    const errors = edit.text === null ? [] : agentProblems(edit.text);
+    let errors = edit.text === null ? [] : agentProblems(edit.text);
+    // Nor does it write values its review would hide.
+    if (edit.text !== null && errors.length === 0 && shownText(edit.text) !== edit.text)
+        errors = [
+            "ccdesk does not write env, header or URL values it would then hide; add them in your editor instead.",
+        ];
     return {
         path,
         raw,

package/dist/server/mcp-edit.js

@@ -44,10 +44,12 @@ function secretsIn(args) {
         }
     });
 }
-export const runClaude = async (args, cwd) => {
+export const runClaude = async (args, cwd, configDir) => {
     const program = await claudeProgram();
+    // Set only for a chosen profile: Claude Code also moves .claude.json into a CLAUDE_CONFIG_DIR.
+    const env = configDir === undefined ? process.env : { ...process.env, CLAUDE_CONFIG_DIR: configDir };
     return new Promise((done, fail) => {
-        execFile(program, args, { cwd, timeout: 30_000 }, (error, stdout, stderr) => {
+        execFile(program, args, { cwd, env, timeout: 30_000 }, (error, stdout, stderr) => {
             if (error?.code === "ENOENT")
                 return fail(new RefusedError("ccdesk changes your user and local MCP servers through the claude command, which is not on PATH."));
             // Node's own message repeats the command, with the server's env and header values in it.
@@ -181,7 +183,9 @@ async function planClaudeJson(env, edit, run) {
         name,
         JSON.stringify(definition),
     ];
-    const addCommand = (name, definition) => `claude mcp add-json --scope ${edit.scope} -- ${quoted(name)} ${quoted(JSON.stringify(definition))}`;
+    // The commands shown and recorded name the profile, so pasting one changes the same servers.
+    const claude = env.configDir === undefined ? "claude" : `CLAUDE_CONFIG_DIR=${quoted(env.configDir)} claude`;
+    const addCommand = (name, definition) => `${claude} mcp add-json --scope ${edit.scope} -- ${quoted(name)} ${quoted(JSON.stringify(definition))}`;
     const before = Object.keys(servers).length > 0 ? shown(servers) : null;
     // Recent changes lists the edit with the servers it touched, values hidden as the page shows
     // them, and the commands that put them back from the folder claude ran in.
@@ -194,7 +198,7 @@ async function planClaudeJson(env, edit, run) {
             shownBefore: shown(touched(servers)),
             shownAfter: shown(touched(edited(servers, edit))),
             undoCommands: [
-                ...(add ? [`${at}claude mcp remove --scope ${edit.scope} -- ${quoted(add.name)}`] : []),
+                ...(add ? [`${at}${claude} mcp remove --scope ${edit.scope} -- ${quoted(add.name)}`] : []),
                 ...(remove ? [`${at}${addCommand(remove.name, redactSecrets(servers[remove.name]))}`] : []),
             ],
         });
@@ -211,20 +215,20 @@ async function planClaudeJson(env, edit, run) {
             errors,
             // Shown with secrets hidden; the command that runs has the values you typed.
             commands: [
-                ...(remove ? [`claude mcp remove --scope ${edit.scope} -- ${quoted(remove.name)}`] : []),
+                ...(remove ? [`${claude} mcp remove --scope ${edit.scope} -- ${quoted(remove.name)}`] : []),
                 ...(add ? [addCommand(add.name, redactSecrets(add.definition))] : []),
             ],
         },
         save: async () => {
             if (remove)
-                await run(["mcp", "remove", "--scope", edit.scope, "--", remove.name], cwd);
+                await run(["mcp", "remove", "--scope", edit.scope, "--", remove.name], cwd, env.configDir);
             // The change is made by then; a record that cannot be written only leaves it unlisted.
             if (!add) {
                 await record().catch(() => undefined);
                 return { target: env.claudeJson };
             }
             try {
-                await run(addArgs(add.name, add.definition), cwd);
+                await run(addArgs(add.name, add.definition), cwd, env.configDir);
             }
             catch (error) {
                 if (!remove)
@@ -234,7 +238,7 @@ async function planClaudeJson(env, edit, run) {
                 // belongs to; a replaced server has no hidden values (see checked), so the command shows
                 // nothing the page does not.
                 const original = servers[remove.name];
-                await run(addArgs(remove.name, original), cwd).catch(() => {
+                await run(addArgs(remove.name, original), cwd, env.configDir).catch(() => {
                     throw new RefusedError(`ccdesk removed ${remove.name}, then could not add it back. In bash, zsh or Git Bash, put it back with: ${edit.scope === "local" ? `cd ${quoted(cwd)} && ` : ""}${addCommand(remove.name, original)} (${error instanceof Error ? error.message : String(error)})`);
                 });
                 throw error;

package/dist/server/scan/compare.js

@@ -1,4 +1,5 @@
 import { resolve } from "node:path";
+import { isDeepStrictEqual } from "node:util";
 import {} from "../../shared/compare.js";
 import {} from "./env.js";
 import { effectiveSettings, readSettingsLayers } from "./settings.js";
@@ -28,7 +29,8 @@ export async function compareSettings(env, a, b) {
     const settings = keys.map((key) => {
         const x = left.get(key) ?? null;
         const y = right.get(key) ?? null;
-        return { key, a: x, b: y, same: JSON.stringify(x?.value) === JSON.stringify(y?.value) };
+        // The order keys are written in does not change a setting.
+        return { key, a: x, b: y, same: isDeepStrictEqual(x?.value, y?.value) };
     });
     return { a: resolve(a), b: resolve(b), settings };
 }

package/dist/server/scan/context.js

@@ -1,7 +1,7 @@
 import { basename, join } from "node:path";
 import {} from "../../shared/types.js";
 import {} from "./env.js";
-import { isWithin, parseFrontmatter, readTextFile } from "./files.js";
+import { isWithin, parseFrontmatter, readTextFile, resolvedPath } from "./files.js";
 /**
  * Imports can name any file, so a cloned repo's CLAUDE.md could point at private files.
  * ccdesk shows an import's text only from the project, your Claude folders and ~/.agents.
@@ -71,8 +71,11 @@ export async function buildContext(input) {
                 note: "ccdesk could not find this style's file",
             }, null));
     }
-    // A file both imported and loaded on its own (a rule, an AGENTS.md) is counted once, as itself.
-    const loaded = new Set(instructions.filter((i) => i.status === "loaded").map((i) => i.path));
+    // A file both imported and loaded on its own (a rule, an AGENTS.md) is counted once, as itself,
+    // also when it is loaded through a link, to it or to its folder, and imported by its real path.
+    const loaded = new Set((await Promise.all(instructions
+        .filter((i) => i.status === "loaded")
+        .map(async (i) => [i.path, i.realPath ?? (await resolvedPath(i.path))]))).flat());
     const added = new Set();
     // An imported file comes before the text that imports it ("Claude reads the imported file
     // first, then the rest"), and its own imports before it.

package/dist/server/scan/env.js

@@ -3,10 +3,13 @@ import { join, resolve } from "node:path";
 /** `configDirFlag`, from `--config-dir`, stands in for CLAUDE_CONFIG_DIR and wins over it. */
 export function scanEnvFromProcess(configDirFlag) {
     const home = homedir();
-    const configDir = configDirFlag !== undefined ? resolve(configDirFlag) : process.env.CLAUDE_CONFIG_DIR;
+    // Made absolute here, from the folder ccdesk started in, because claude runs elsewhere.
+    const chosen = configDirFlag ?? (process.env.CLAUDE_CONFIG_DIR || undefined);
+    const configDir = chosen === undefined ? undefined : resolve(chosen);
     return {
         home,
         claudeDir: configDir ?? join(home, ".claude"),
+        configDir,
         // Claude Code keeps .claude.json beside the config dir it was given.
         claudeJson: configDir ? join(configDir, ".claude.json") : join(home, ".claude.json"),
         managedDir: managedDirFor(process.platform),

package/dist/server/scan/files.js

@@ -152,7 +152,9 @@ export function wildcard(pattern, flags = "") {
 }
 export function isWithin(parent, child) {
     const rel = relative(parent, child);
-    return rel === "" || (!rel.startsWith("..") && !rel.startsWith(sep) && !/^[a-zA-Z]:/.test(rel));
+    // Only the parent segment leads out; a name such as ..cache is inside.
+    const up = rel === ".." || rel.startsWith(`..${sep}`);
+    return rel === "" || (!up && !rel.startsWith(sep) && !/^[a-zA-Z]:/.test(rel));
 }
 export async function isDir(path) {
     try {

package/dist/server/scan/path-test.js

@@ -1,7 +1,7 @@
 import { dirname, isAbsolute, join, matchesGlob, relative, resolve, sep } from "node:path";
 import {} from "../../shared/types.js";
 import {} from "./env.js";
-import { isFile, isWithin, listDir, parseFrontmatter, readTextFile, stringsIn, toStringList, walkMarkdown, } from "./files.js";
+import { isFile, isWithin, listDir, MAX_TEXT_BYTES, parseFrontmatter, readTextFile, resolvedPath, stringsIn, toStringList, walkMarkdown, } from "./files.js";
 import { scanDirectory } from "./index.js";
 import { applySkillOverrides, readSkill } from "./inventory.js";
 /** Globs are written with forward slashes on every platform. */
@@ -46,6 +46,8 @@ viewOf = (cwd) => scanDirectory(env, cwd)) {
         if (glob)
             matches.push({ kind: "rule", path: rule.path, scope: rule.scope, glob });
     }
+    const realCwd = await resolvedPath(cwd);
+    const approved = view.trust.externalImports === "approved";
     // Folders below the start directory load their own instructions, rules and skills on demand.
     const mode = view.agentsMdMode;
     const startSkills = new Set(view.inventory.skills.filter((s) => s.scope !== "plugin").map((s) => s.name));
@@ -53,11 +55,14 @@ viewOf = (cwd) => scanDirectory(env, cwd)) {
     for (let d = dirname(target); d !== cwd && isWithin(cwd, d); d = dirname(d))
         between.unshift(d);
     for (const folder of between) {
+        /** Whether the file is there; an excluded one or one over the limit is there but not loaded. */
         const nested = async (name, scope) => {
             const path = join(folder, name);
-            if (excluded(path) || !(await readTextFile(env, path)))
+            const file = await readTextFile(env, path);
+            if (!file)
                 return false;
-            matches.push({ kind: "nested", path, scope });
+            if (!excluded(path) && file.bytes <= MAX_TEXT_BYTES)
+                matches.push({ kind: "nested", path, scope });
             return true;
         };
         // managed-only leaves out files at launch, but a subfolder's CLAUDE.md and rules still load
@@ -73,9 +78,19 @@ viewOf = (cwd) => scanDirectory(env, cwd)) {
             await nested("AGENTS.md", "project");
         for (const path of await walkMarkdown(join(folder, ".claude", "rules"))) {
             const text = await readTextFile(env, path);
-            if (!text || excluded(path))
+            if (!text || text.bytes > MAX_TEXT_BYTES || excluded(path))
+                continue;
+            // As at startup: excluded by its target's path too, and a rule linked from outside the
+            // project waits for your approval, then loads only without paths
+            // (docs: memory#share-rules-across-projects-with-symlinks).
+            const real = await resolvedPath(path);
+            const outside = !isWithin(realCwd, real) && !isWithin(await resolvedPath(folder), real);
+            const linked = text.realPath ?? (outside ? real : undefined);
+            if (linked !== undefined && excluded(linked))
                 continue;
             const globs = toStringList(parseFrontmatter(text.text).data.paths);
+            if (!isWithin(realCwd, real) && (!approved || globs.length > 0))
+                continue;
             const glob = globs.length === 0 ? undefined : firstMatch(globs, slashed(relative(folder, target)));
             if (globs.length === 0 || glob)
                 matches.push({ kind: "nested", path, scope: "project", ...(glob ? { glob } : {}) });

package/dist/server/scan/permissions.js

@@ -17,7 +17,7 @@ export function trustWaits({ trust, inConfigHome, localFromRepository, profile,
 }
 /**
  * An MCP rule with a parameter, which Claude Code skips when it reads a settings file; such a rule
- * works only from --disallowedTools (docs: permissions#match-specific-tool-uses).
+ * works only from --disallowedTools (docs: permissions#match-by-input-parameter).
  */
 export function isSkippedMcpRule(rule) {
     return /^mcp__[^(]*\(/.test(rule);

package/dist/server/scan/usage.js

@@ -36,6 +36,9 @@ export class CountStopped extends Error {
 export function readUsage(env, dir, rules, { signal, timeLimitMs = TIME_LIMIT_MS, maxCachedCalls = MAX_CACHED_CALLS, } = {}) {
     const key = JSON.stringify([env.claudeDir, resolve(dir), rules, timeLimitMs, maxCachedCalls]);
     let run = waiting.get(key);
+    // Nobody would wait for a new count, so none starts to hold up the queue.
+    if (!run && signal?.aborted)
+        return Promise.reject(stoppedBecause(signal));
     if (!run) {
         const stop = new AbortController();
         const promise = queue.then(() => {

package/dist/server/settings-edit.js

@@ -1,5 +1,6 @@
 import { stat } from "node:fs/promises";
 import {} from "ajv";
+import HOOK_EVENTS from "../shared/hook-events.json" with { type: "json" };
 import { allowedScopes, ignoredReason } from "../shared/scopes.js";
 import schema from "../shared/settings.schema.json" with { type: "json" };
 import {} from "../shared/types.js";
@@ -72,7 +73,9 @@ async function planKey(env, file, key, value, checksHiddenValues = false) {
     // reformatted instead of diffing its raw text.
     const reformats = raw !== null && raw.trim() !== "" && raw !== `${JSON.stringify(data, null, 2)}\n`;
     const base = { path, before, revision: revisionOf(raw), reformats };
-    const errors = nextValue === undefined ? [] : schemaErrors(validate, nextValue, key);
+    const errors = nextValue === undefined
+        ? []
+        : [...schemaErrors(validate, nextValue, key), ...newHookEvents(key, data[key], nextValue)];
     if (errors.length > 0)
         return {
             path,
@@ -128,6 +131,18 @@ async function planPermissionEdit(env, edit) {
         return Object.keys(permissions).length > 0 ? permissions : undefined;
     });
 }
+/**
+ * Hook events an edit brings in that Claude Code does not know, which the schema allows. Ones the
+ * file already has stay, so a file written for another Claude Code version can still be edited.
+ */
+function newHookEvents(key, before, after) {
+    if (key !== "hooks" || !isRecord(after))
+        return [];
+    const had = isRecord(before) ? Object.keys(before) : [];
+    return Object.keys(after)
+        .filter((event) => !HOOK_EVENTS.includes(event) && !had.includes(event))
+        .map((event) => `${event} is not a hook event Claude Code knows.`);
+}
 /** The matcher a group is written with; a missing or empty one matches everything. */
 function matcherOf(group) {
     return isRecord(group) && typeof group.matcher === "string" ? group.matcher : "";
@@ -144,6 +159,9 @@ async function planHookEdit(env, edit) {
             return Array.isArray(groups) ? groups : [];
         };
         const { remove, add } = edit;
+        // Checked before any branch, so neither a new hook nor a replacement writes them.
+        if (add && hasHiddenValues(add.definition))
+            throw new RefusedError("ccdesk does not write header values it would then hide; add this hook in the file instead.");
         if (remove) {
             const groups = groupsOf(remove.event);
             const group = groups[remove.at.group];
@@ -175,8 +193,6 @@ async function planHookEdit(env, edit) {
                 delete hooks[remove.event];
         }
         if (add) {
-            if (hasHiddenValues(add.definition))
-                throw new RefusedError("ccdesk does not write header values it would then hide; add this hook in the file instead.");
             const groups = groupsOf(add.event);
             const matcher = add.matcher ?? "";
             const group = groups.find((g) => matcherOf(g) === matcher && isRecord(g) && Array.isArray(g.hooks));

package/dist/server/watch.js

@@ -1,11 +1,12 @@
 import { watch } from "node:fs";
 import { stat } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, isAbsolute, join } from "node:path";
 import { storeDirName } from "../shared/memory.js";
 import {} from "../shared/types.js";
 import {} from "./scan/env.js";
-import { isNetworkPath, mainWorktreeRoot } from "./scan/files.js";
+import { isDir, isFile, isNetworkPath, mainWorktreeRoot } from "./scan/files.js";
 import { scanDirectory } from "./scan/index.js";
+import { manifestCommandMap, manifestPaths } from "./scan/plugins.js";
 /** How long one request waits for a change before answering "nothing changed". */
 const WAIT_MS = 25_000;
 /** Editors write a file in several steps; one change covers them all. */
@@ -31,7 +32,8 @@ async function targets(env, dir, extra) {
     const memoryKey = (await mainWorktreeRoot(dir)) ?? dir;
     const out = [
         ...claude(env.claudeDir),
-        { path: join(env.claudeDir, "plugins"), recursive: false },
+        // Only the install list: Windows reports a write deep in a plugin as a change to `cache`.
+        { path: join(env.claudeDir, "plugins"), recursive: false, names: ["installed_plugins.json"] },
         { path: join(env.claudeDir, "projects", storeDirName(memoryKey), "memory"), recursive: false },
         { path: env.managedDir, recursive: false },
         { path: join(env.managedDir, "managed-settings.d"), recursive: false },
@@ -53,11 +55,15 @@ async function targets(env, dir, extra) {
         out.push(...claude(join(memoryKey, ".claude")));
     return out.filter((t) => !isNetworkPath(t.path));
 }
-/** Files a scan read that the fixed list does not cover: a custom memory folder, imports. */
-export function dependencies(view) {
+/**
+ * Files a scan read that the fixed list does not cover: a custom memory folder, imports, installed
+ * plugins. A missing import is watched too, so creating it shows up, even when its folder is missing
+ * as well.
+ */
+export async function dependencies(env, view) {
     const files = view.instructions.flatMap((i) => [
         i.realPath ?? i.path,
-        ...i.imports.filter((r) => r.exists).map((r) => r.resolved),
+        ...i.imports.map((r) => r.resolved),
     ]);
     const byFolder = new Map();
     for (const file of files) {
@@ -65,10 +71,69 @@ export function dependencies(view) {
         names.add(basename(file));
         byFolder.set(dirname(file), names);
     }
+    const plugins = await Promise.all(view.inventory.plugins.map((p) => pluginTargets(env, view, p)));
     return [
         ...[...byFolder].map(([path, names]) => ({ path, recursive: false, names: [...names] })),
         ...(view.memory ? [{ path: view.memory.dir, recursive: false }] : []),
+        ...plugins.flat(),
+    ];
+}
+/** A plugin's folders the scan reads from, when they are not named in its manifest. */
+const PLUGIN_FOLDERS = ["agents", "skills", "commands", "output-styles", "hooks"];
+/** Manifest keys that name files or folders inside the plugin. */
+const PLUGIN_KEYS = ["agents", "skills", "commands", "outputStyles", "hooks", "mcpServers"];
+/**
+ * What the scan reads in a plugin: its manifest, .mcp.json, a skill at its root, its component
+ * folders and the paths its manifest names. Not the whole plugin, which can hold an MCP server's
+ * node_modules and files the server writes while it runs.
+ */
+async function pluginTargets(env, view, plugin) {
+    const root = plugin.installPath;
+    // A path from installed_plugins.json that is not absolute names no folder Claude Code would load.
+    if (!isAbsolute(root))
+        return [];
+    const named = await Promise.all(PLUGIN_KEYS.map((key) => manifestPaths(env, plugin, key)));
+    const commands = await manifestCommandMap(env, plugin);
+    // Without a skills folder, each folder at the root holding SKILL.md is a skill.
+    const rootSkills = view.inventory.skills
+        .filter((s) => s.plugin === plugin.id && s.folder && dirname(s.folder) === root)
+        .map((s) => s.folder);
+    const paths = [
+        ...PLUGIN_FOLDERS.map((name) => join(root, name)),
+        ...named.flatMap((list) => list ?? []),
+        ...commands.map((c) => c.path),
+        ...rootSkills,
+    ];
+    const out = [
+        {
+            path: root,
+            recursive: false,
+            names: [".claude-plugin", ".mcp.json", "SKILL.md", ...PLUGIN_FOLDERS],
+        },
+        { path: join(root, ".claude-plugin"), recursive: false, names: ["plugin.json"] },
     ];
+    for (const path of new Set(paths)) {
+        if (await isDir(path))
+            out.push({ path, recursive: true });
+        else if (await isFile(path))
+            out.push({ path: dirname(path), recursive: false, names: [basename(path)] });
+    }
+    return out;
+}
+/**
+ * `target`, or when it does not exist yet, the nearest folder above it that does, watched for the
+ * next missing name only. Watching needs a folder that exists, and the watchers are rebuilt after
+ * every change, so each folder that appears moves the watch one level closer.
+ */
+async function nearestWatchable(target) {
+    if (isNetworkPath(target.path) || (await stat(target.path).catch(() => null)))
+        return target;
+    for (let missing = target.path; dirname(missing) !== missing; missing = dirname(missing)) {
+        const parent = dirname(missing);
+        if (await stat(parent).catch(() => null))
+            return { path: parent, recursive: false, names: [basename(missing)] };
+    }
+    return target;
 }
 /** One set of file watchers per directory a page is looking at, shared by its requests. */
 export class Watcher {
@@ -91,7 +156,7 @@ export class Watcher {
         // Only a watched directory's view can be known to be current later.
         if (subscription)
             this.latest.set(view.path, { view, startedAt, stateFile });
-        const extra = dependencies(view);
+        const extra = await dependencies(this.env, view);
         this.scanned.set(view.path, extra);
         if (subscription && JSON.stringify(extra) !== JSON.stringify(subscription.extra)) {
             subscription.extra = extra;
@@ -128,8 +193,10 @@ export class Watcher {
     async wait(dir, since, signal, timeoutMs = WAIT_MS) {
         const subscription = await this.subscribe(dir);
         clearTimeout(subscription.idle);
+        // Closed while its watchers were starting: there is nothing left to wait on.
+        const closed = this.subscriptions.get(dir) !== subscription;
         try {
-            if (subscription.changedAt <= since && !signal.aborted)
+            if (!closed && subscription.changedAt <= since && !signal.aborted)
                 await new Promise((resolve) => {
                     const done = () => {
                         clearTimeout(timer);
@@ -143,7 +210,8 @@ export class Watcher {
                 });
         }
         finally {
-            if (subscription.waiters.size === 0)
+            // A dropped subscription has nothing left to clean up later.
+            if (subscription.waiters.size === 0 && this.subscriptions.get(dir) === subscription)
                 subscription.idle = setTimeout(() => this.drop(dir), IDLE_MS);
         }
         return { changed: subscription.changedAt > since, at: subscription.changedAt };
@@ -178,10 +246,14 @@ export class Watcher {
             w.close();
         this.subscriptions.delete(dir);
         this.latest.delete(dir);
+        // Pages still waiting are answered now, so no timer outlives the watcher.
+        for (const wake of [...subscription.waiters])
+            wake();
     }
     /** (Re)creates the watchers, so a folder created since, such as a new .claude, is watched. */
     async rewatch(dir, subscription) {
-        const list = await targets(this.env, dir, subscription.extra);
+        const extra = await Promise.all(subscription.extra.map(nearestWatchable));
+        const list = await targets(this.env, dir, extra);
         for (const w of subscription.watchers)
             w.close();
         subscription.watchers = [];