ccdesk 0.0.0-stage → 0.1.0

package/dist/server/scan/instructions.js

@@ -0,0 +1,285 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, matchesGlob, parse, resolve } from "node:path";
+import {} from "../../shared/types.js";
+import {} from "./env.js";
+import { isFile, isNetworkPath, isWithin, MAX_TEXT_BYTES, parseFrontmatter, readTextFile, resolvedPath, toStringList, walkMarkdown, } from "./files.js";
+const MAX_IMPORT_HOPS = 4;
+export const AGENTS_MD_MODES = [
+    "claude-md-or-agents-md",
+    "claude-md-and-agents-md",
+    "claude-md",
+    "managed-only",
+];
+/** Directories from the filesystem root down to `cwd`, the order Claude Code concatenates them in. */
+export function ancestorsRootFirst(cwd) {
+    const dirs = [];
+    let current = resolve(cwd);
+    const { root } = parse(current);
+    while (true) {
+        dirs.unshift(current);
+        if (current === root)
+            break;
+        current = dirname(current);
+    }
+    return dirs;
+}
+/**
+ * The instruction files Claude Code reads in `cwd`, in load order, each with whether it loads at
+ * session start, when Claude works with matching files, or not at all, and why.
+ * Follows code.claude.com/docs/en/memory.
+ */
+export async function resolveInstructions(options) {
+    const { env, cwd, mode, excludes, externalImports, managedClaudeMd, problems } = options;
+    /** A file that exists but cannot be read is reported, not taken for a missing one. */
+    const readInstruction = async (path) => {
+        const file = await readTextFile(path);
+        if (file || !(await stat(path).catch(() => null))?.isFile())
+            return file;
+        const denied = await access(path, constants.R_OK).then(() => null, (error) => error.code ?? String(error));
+        if (denied)
+            problems.push({ path, error: `cannot be read (${denied})` });
+        return null;
+    };
+    const ctx = {
+        realCwd: await resolvedPath(resolve(cwd)),
+        home: env.home,
+        approved: externalImports === "approved",
+    };
+    const managedOnly = mode === "managed-only";
+    const skippedByMode = `Skipped: instruction mode is ${mode}`;
+    const out = [];
+    const managed = await readInstruction(join(env.managedDir, "CLAUDE.md"));
+    if (managed)
+        out.push(await instruction(managed, "claude-md", "managed", env.managedDir, ctx, "Organisation policy, always loaded"));
+    if (managedClaudeMd) {
+        const { path, text } = managedClaudeMd;
+        const file = {
+            path,
+            mtime: "",
+            bytes: Buffer.byteLength(text),
+            lines: text.split("\n").length,
+            text,
+        };
+        const entry = await instruction(file, "claude-md", "managed", env.managedDir, ctx, "Organisation policy from the claudeMd key in managed settings");
+        entry.imports = [];
+        out.push(entry);
+    }
+    const user = await readInstruction(join(env.claudeDir, "CLAUDE.md"));
+    if (user)
+        out.push(await instruction(user, "claude-md", "user", env.claudeDir, ctx, "Your instructions for every project"));
+    for (const path of await walkMarkdown(join(env.claudeDir, "rules"))) {
+        const file = await readInstruction(path);
+        if (file)
+            out.push(await rule(file, "user", env.claudeDir, ctx));
+    }
+    // Per directory, root first: CLAUDE.md, .claude/CLAUDE.md, rules, then CLAUDE.local.md last
+    // ("your personal notes are the last thing Claude reads at that level"), then AGENTS.md.
+    const claudeFiles = [];
+    const agentsFiles = [];
+    for (const dir of ancestorsRootFirst(cwd)) {
+        // ~/.claude/CLAUDE.md and ~/.claude/rules are the user files above, not the home's project files.
+        const isConfigHome = join(dir, ".claude") === env.claudeDir;
+        for (const name of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
+            if (isConfigHome && name === ".claude/CLAUDE.md")
+                continue;
+            const file = await readInstruction(join(dir, name));
+            if (file)
+                claudeFiles.push(await instruction(file, "claude-md", "project", dir, ctx, ""));
+        }
+        if (!isConfigHome && dir !== env.claudeDir)
+            for (const path of await walkMarkdown(join(dir, ".claude", "rules"))) {
+                const file = await readInstruction(path);
+                if (file)
+                    claudeFiles.push(await rule(file, "project", dir, ctx));
+            }
+        const local = await readInstruction(join(dir, "CLAUDE.local.md"));
+        if (local)
+            claudeFiles.push(await instruction(local, "claude-local-md", "local", dir, ctx, ""));
+        for (const name of ["AGENTS.md", ".claude/AGENTS.md"]) {
+            const file = await readInstruction(join(dir, name));
+            if (file)
+                agentsFiles.push(await instruction(file, "agents-md", "project", dir, ctx, ""));
+        }
+    }
+    const hasClaudeMd = claudeFiles.some((f) => f.kind !== "rule");
+    for (const file of claudeFiles) {
+        if (file.kind === "rule")
+            continue;
+        file.reason =
+            file.kind === "claude-local-md"
+                ? "Your private notes for this directory"
+                : file.dir === resolve(cwd)
+                    ? "Instructions for this directory"
+                    : "Inherited from a parent directory";
+    }
+    const includedElsewhere = new Set(claudeFiles.flatMap((f) => [f.realPath ?? f.path, ...f.imports.map((i) => i.resolved)]));
+    for (const file of agentsFiles) {
+        if (mode === "managed-only" || mode === "claude-md")
+            skip(file, skippedByMode);
+        else if (includedElsewhere.has(file.realPath ?? file.path))
+            skip(file, "Already included through a CLAUDE.md import or symlink");
+        else if (mode === "claude-md-and-agents-md")
+            file.reason = "Loaded alongside CLAUDE.md (instruction mode claude-md-and-agents-md)";
+        else if (hasClaudeMd)
+            skip(file, "Ignored: a CLAUDE.md or CLAUDE.local.md exists here or above, so Claude Code reads that instead");
+        else
+            file.reason = "Loaded because there is no CLAUDE.md here or above";
+    }
+    for (const dir of ancestorsRootFirst(cwd))
+        out.push(...claudeFiles.filter((f) => f.dir === dir), ...agentsFiles.filter((f) => f.dir === dir));
+    const waiting = externalImports === "declined"
+        ? "You declined imports from outside this project"
+        : "Waits for you to approve imports from outside this project";
+    for (const file of out) {
+        if (file.scope === "managed")
+            continue;
+        // Path-scoped rules still load on demand in managed-only mode (docs: memory#choose-which-instruction-files-load).
+        if (managedOnly && file.status === "loaded")
+            skip(file, skippedByMode);
+        // Managed files cannot be excluded; a linked file is excluded by its own path or its target's
+        // (docs: memory#exclude-specific-claude-md-files).
+        const excluded = excludes.some((glob) => [file.path, file.realPath].some((p) => p !== undefined && safeMatch(p, glob)));
+        if (excluded)
+            skip(file, "Skipped by claudeMdExcludes");
+        if (file.status !== "skipped" && file.bytes > MAX_TEXT_BYTES)
+            skip(file, "Skipped: Claude Code does not load an instruction file over 4 MiB");
+        // A project's links outside it need your approval, like its imports; your own files do not.
+        if (file.scope !== "project" && file.scope !== "local")
+            continue;
+        if (file.kind === "rule" && file.realPath && !isWithin(ctx.realCwd, file.realPath)) {
+            if (!ctx.approved)
+                skip(file, `${waiting}; this rule links outside it`);
+            else if (file.paths)
+                skip(file, "Links outside this project, so its paths field is not used");
+        }
+    }
+    addChecks(out);
+    return out;
+}
+function skip(file, reason) {
+    if (file.status === "skipped")
+        return;
+    file.status = "skipped";
+    file.reason = reason;
+}
+/** An invalid pattern matches nothing. */
+function safeMatch(path, glob) {
+    try {
+        return matchesGlob(path, glob);
+    }
+    catch {
+        return false;
+    }
+}
+/** Claude Code's docs suggest keeping each CLAUDE.md under this many lines. */
+const LONG_FILE_LINES = 200;
+function paragraphs(text) {
+    return parseFrontmatter(text)
+        .body.split(/\n\s*\n/)
+        .map((p) => p.trim().replace(/\s+/g, " "))
+        .filter((p) => p.length >= 60);
+}
+/** Upkeep notes: files longer than the docs recommend, paragraphs repeated across files, missing imports. */
+function addChecks(files) {
+    const seen = new Map();
+    for (const file of files.filter((f) => f.status !== "skipped")) {
+        if (file.lines > LONG_FILE_LINES)
+            file.checks.push(`${file.lines} lines; Claude Code's docs suggest under ${LONG_FILE_LINES} for better adherence`);
+        const repeated = new Set();
+        for (const paragraph of paragraphs(file.text)) {
+            const first = seen.get(paragraph);
+            if (first && first !== file)
+                repeated.add(first.path);
+            else
+                seen.set(paragraph, file);
+        }
+        for (const path of repeated)
+            file.checks.push(`Repeats a paragraph from ${path}`);
+        // `@name` without a slash or dot is as likely a mention as a path, so only path-like ones count.
+        for (const ref of file.imports)
+            if (!ref.exists && /[./]/.test(ref.raw))
+                file.checks.push(`Imports @${ref.raw}, which does not exist`);
+    }
+}
+async function rule(file, scope, dir, ctx) {
+    const paths = toStringList(parseFrontmatter(file.text).data.paths);
+    const entry = await instruction(file, "rule", scope, dir, ctx, paths.length > 0
+        ? "Loads only when Claude works with matching files"
+        : "Rule loaded every session");
+    if (paths.length > 0) {
+        entry.paths = paths;
+        entry.status = "on-match";
+    }
+    // A rule reached through a linked folder is not a link itself, but its target can be outside.
+    const real = await resolvedPath(file.path);
+    if (!entry.realPath && !isWithin(ctx.realCwd, real) && !isWithin(await resolvedPath(dir), real))
+        entry.realPath = real;
+    return entry;
+}
+async function instruction(file, kind, scope, dir, ctx, reason) {
+    // Your own files' imports load without asking; a project's imports outside it wait for approval.
+    const own = scope === "managed" || scope === "user";
+    const imports = await collectImports(file, ctx, own || ctx.approved);
+    if (!own && !ctx.approved)
+        for (const ref of imports)
+            if (ref.external)
+                ref.pending = true;
+    return { ...file, kind, scope, dir, status: "loaded", reason, imports, checks: [] };
+}
+/**
+ * `@path` imports, depth first up to four hops, each with the file that imports it. An import
+ * outside the project is read only when Claude Code would read it: from your own files, or once
+ * you approved the project's external imports.
+ */
+async function collectImports(file, ctx, readExternal) {
+    const seen = new Set([file.realPath ?? file.path]);
+    const out = [];
+    const visit = async (source, via, hop) => {
+        if (hop >= MAX_IMPORT_HOPS)
+            return;
+        for (const raw of importPaths(source.text)) {
+            const target = expandImport(raw, dirname(source.path), ctx.home);
+            if (isNetworkPath(target))
+                continue;
+            const real = await resolvedPath(target);
+            if (seen.has(real))
+                continue;
+            seen.add(real);
+            const external = !isWithin(ctx.realCwd, real);
+            const imported = !external || readExternal ? await readTextFile(target) : null;
+            const ref = {
+                raw,
+                resolved: real,
+                via,
+                exists: imported !== null || (await isFile(target)),
+                external,
+            };
+            if (imported && imported.bytes > MAX_TEXT_BYTES)
+                ref.tooLarge = true;
+            out.push(ref);
+            if (imported)
+                await visit(imported, real, hop + 1);
+        }
+    };
+    await visit(file, file.path, 0);
+    return out;
+}
+function expandImport(raw, baseDir, home) {
+    const unescaped = raw.replaceAll("\\ ", " ");
+    if (unescaped.startsWith("~/"))
+        return join(home, unescaped.slice(2));
+    return isAbsolute(unescaped) ? unescaped : resolve(baseDir, unescaped);
+}
+/** `@path` references outside code spans and fences; a backslash keeps a space in the path. */
+function importPaths(text) {
+    const withoutFences = text.replace(/^(```|~~~)[\s\S]*?^\1/gm, "");
+    const withoutSpans = withoutFences.replace(/`[^`\n]*`/g, "");
+    const found = [];
+    for (const match of withoutSpans.matchAll(/(?:^|\s)@((?:[^\s\\]|\\ )+)/g)) {
+        const path = match[1]?.replace(/[.,;:!?)\]]+$/, "");
+        if (path)
+            found.push(path);
+    }
+    return found;
+}

package/dist/server/scan/inventory.js

@@ -0,0 +1,360 @@
+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 { ancestorsRootFirst } from "./instructions.js";
+import { readMcpServers } from "./mcp.js";
+import { manifestCommandMap, manifestConfigs, manifestPaths, 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);
+    if (!file)
+        return null;
+    const { data } = parseFrontmatter(file.text);
+    const entry = {
+        name: stringField(data, "name") || name,
+        description: stringField(data, "description"),
+        path,
+        scope,
+        text: file.text,
+    };
+    const model = stringField(data, "model");
+    if (model)
+        entry.model = model;
+    if (plugin)
+        entry.plugin = plugin;
+    const real = await resolvedPath(path);
+    if (real !== path)
+        entry.realPath = real;
+    return entry;
+}
+/**
+ * `*.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) {
+    const out = [];
+    for (const name of await listDir(dir)) {
+        if (name.startsWith("."))
+            continue;
+        const path = join(dir, name);
+        if (await isDir(path)) {
+            if (depth < 4)
+                out.push(...(await readFileEntries(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);
+        if (entry)
+            out.push(entry);
+    }
+    return out;
+}
+/** Files or folders of `.md` files. */
+async function readPaths(paths, scope, options) {
+    const out = [];
+    for (const path of paths) {
+        if (await isDir(path))
+            out.push(...(await readFileEntries(path, scope, options)));
+        else if (path.endsWith(".md")) {
+            const entry = await readEntry(path, basename(path, ".md"), scope, options.plugin);
+            if (entry)
+                out.push(entry);
+        }
+    }
+    return out;
+}
+export async function readSkill(folder, scope, plugin) {
+    const path = join(folder, "SKILL.md");
+    const file = await readTextFile(path);
+    if (!file)
+        return null;
+    const { data, body } = parseFrontmatter(file.text);
+    const entry = {
+        name: stringField(data, "name") || (folder.split(/[/\\]/).pop() ?? ""),
+        // Without a description, Claude Code lists the first non-empty line of the body.
+        description: stringField(data, "description") ||
+            (body.split("\n").find((line) => line.trim() !== "") ?? "").trim(),
+        path,
+        folder,
+        listed: !isTrue(data["disable-model-invocation"]),
+        scope,
+        text: file.text,
+    };
+    const paths = toStringList(data.paths);
+    if (paths.length > 0)
+        entry.paths = paths;
+    const whenToUse = stringField(data, "when_to_use");
+    if (whenToUse)
+        entry.whenToUse = whenToUse;
+    const model = stringField(data, "model");
+    if (model)
+        entry.model = model;
+    if (plugin)
+        entry.plugin = plugin;
+    const real = await resolvedPath(folder);
+    if (real !== folder)
+        entry.realPath = real;
+    return entry;
+}
+/** `<name>/SKILL.md` folders, or one folder holding SKILL.md itself. */
+async function readSkills(dir, scope, plugin) {
+    if (plugin && (await isFile(join(dir, "SKILL.md")))) {
+        const skill = await readSkill(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);
+        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) {
+    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 skillDirs = [join(root, "skills"), ...(extraSkills ?? [])];
+    const rootSkill = extraSkills === null && !(await isDir(join(root, "skills")));
+    const skills = rootSkill ? await readSkills(root, "plugin", plugin.id) : [];
+    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", {
+        ...options,
+        separator,
+    });
+    const commands = await listed("commands", "commands", ":");
+    for (const c of await manifestCommandMap(plugin))
+        commands.push(c.text === null
+            ? ((await readEntry(c.path, c.name, "plugin", plugin.id)) ?? {
+                name: c.name,
+                description: c.description,
+                path: c.path,
+                scope: "plugin",
+                plugin: plugin.id,
+                text: "",
+            })
+            : {
+                name: c.name,
+                description: c.description,
+                path: c.path,
+                scope: "plugin",
+                plugin: plugin.id,
+                text: c.text,
+            });
+    // 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")]) {
+        const folder = (await isDir(path)) ? path : null;
+        for (const agent of await readPaths([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(":");
+            agents.push(agent);
+        }
+    }
+    return {
+        skills,
+        agents,
+        commands,
+        outputStyles: await listed("outputStyles", "output-styles"),
+    };
+}
+/**
+ * The `.claude/<sub>` folders of the start directory and every parent up to the repository root
+ * (only the start directory outside git), root first, leaving out the user folder.
+ */
+function projectFolders(env, projectDir, gitRoot, sub) {
+    return ancestorsRootFirst(projectDir)
+        .filter((dir) => !gitRoot || isWithin(gitRoot, dir))
+        .slice(gitRoot ? 0 : -1)
+        .map((dir) => join(dir, ".claude", sub))
+        .filter((dir) => dir !== join(env.claudeDir, sub));
+}
+/**
+ * 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).
+ */
+async function readAgents(env, projectDir, gitRoot) {
+    const sources = [
+        [join(env.managedDir, ".claude", "agents"), "managed"],
+        ...projectFolders(env, projectDir, gitRoot, "agents")
+            .reverse()
+            .map((dir) => [dir, "project"]),
+        [join(env.claudeDir, "agents"), "user"],
+    ];
+    const agents = [];
+    const winners = new Map();
+    for (const [dir, scope] of sources)
+        for (const agent of await readFileEntries(dir, scope)) {
+            const winner = winners.get(agent.name);
+            if (winner)
+                agent.shadowedBy = winner.path;
+            else
+                winners.set(agent.name, agent);
+            agents.push(agent);
+        }
+    return agents;
+}
+/**
+ * Applies skillOverrides to your skills and command files; plugin skills are not affected
+ * (docs: skills#override-skill-visibility-from-settings).
+ */
+export function applySkillOverrides(entries, overrides) {
+    if (!isRecord(overrides))
+        return;
+    for (const entry of entries) {
+        const state = overrides[entry.name];
+        if (entry.scope === "plugin")
+            continue;
+        if (state !== "name-only" && state !== "user-invocable-only" && state !== "off")
+            continue;
+        entry.override = state;
+        if (state !== "name-only")
+            entry.listed = false;
+    }
+}
+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 projectClaude = join(projectDir, ".claude");
+    const hasProjectDir = projectClaude !== env.claudeDir;
+    const files = async (sub, separator = "/") => [
+        ...(await readFileEntries(join(env.claudeDir, sub), "user", { separator })),
+        ...(hasProjectDir
+            ? await readFileEntries(join(projectClaude, sub), "project", { separator })
+            : []),
+    ];
+    // Project skills come from the start directory and every parent up to the repository root.
+    const skillDirs = [
+        [join(env.managedDir, ".claude", "skills"), "managed"],
+        [join(env.claudeDir, "skills"), "user"],
+        ...(await listDir(join(env.claudeDir, "skills", "synced")))
+            .filter((bucket) => !bucket.startsWith("."))
+            .map((bucket) => [join(env.claudeDir, "skills", "synced", bucket), "user"]),
+        ...projectFolders(env, projectDir, gitRoot, "skills").map((dir) => [
+            dir,
+            "project",
+        ]),
+    ];
+    const skills = [];
+    const seenFolders = new Set();
+    for (const [dir, scope] of skillDirs) {
+        for (const skill of await readSkills(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);
+            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)
+        if (isTrue(parseFrontmatter(command.text).data["disable-model-invocation"]))
+            command.listed = false;
+    const overrides = effectiveSettings(layers).find((s) => s.key === "skillOverrides")?.value;
+    applySkillOverrides([...skills, ...commands], overrides);
+    return {
+        agents: [
+            ...(await readAgents(env, projectDir, gitRoot)),
+            ...fromPlugins.flatMap((p) => p.agents),
+        ],
+        skills: [...skills, ...fromPlugins.flatMap((p) => p.skills)],
+        commands: [...commands, ...fromPlugins.flatMap((p) => p.commands)],
+        outputStyles: [
+            ...(await files("output-styles")),
+            ...fromPlugins.flatMap((p) => p.outputStyles),
+        ],
+        hooks: await readHooks(layers, active),
+        mcpServers: await readMcpServers(input, active),
+        plugins,
+    };
+}
+async function readHooks(layers, plugins) {
+    const out = [];
+    for (const layer of layers) {
+        if (layer.data)
+            out.push(...hooksFrom(layer.data.hooks, layer.scope, layer.path));
+    }
+    for (const plugin of plugins) {
+        const path = join(plugin.installPath, "hooks", "hooks.json");
+        const file = await readJsonObject(path);
+        if (file.ok)
+            out.push(...hooksFrom(file.data.hooks, "plugin", path, plugin));
+        for (const part of await manifestConfigs(plugin, "hooks"))
+            out.push(...hooksFrom(part.value, "plugin", part.path, plugin));
+    }
+    // docs: hooks#disable-or-remove-hooks, settings-reference#allowmanagedhooksonly
+    const managed = layers.find((l) => l.scope === "managed")?.data;
+    const managedOff = managed?.disableAllHooks === true;
+    // The value left after precedence counts, so a project false beats a user true.
+    const othersOff = HIGHEST_FIRST.filter((s) => s !== "managed")
+        .flatMap((scope) => layers.filter((l) => l.scope === scope))
+        .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));
+    for (const hook of out) {
+        const organisation = hook.source === "managed" || (hook.plugin !== undefined && forcedByManaged.has(hook.plugin));
+        if (managedOff) {
+            hook.active = false;
+            hook.note = "Managed settings turn off every hook (disableAllHooks)";
+        }
+        else if (hook.source !== "managed" && othersOff) {
+            hook.active = false;
+            hook.note = "disableAllHooks is on, so only managed hooks run";
+        }
+        else if (!organisation && managedOnly) {
+            hook.active = false;
+            hook.note = "Managed settings allow only managed hooks (allowManagedHooksOnly)";
+        }
+    }
+    return out;
+}
+function hooksFrom(config, source, sourcePath, plugin) {
+    if (!isRecord(config))
+        return [];
+    const out = [];
+    for (const [event, groups] of Object.entries(config)) {
+        if (!Array.isArray(groups))
+            continue;
+        for (const group of groups) {
+            if (!isRecord(group) || !Array.isArray(group.hooks))
+                continue;
+            for (const h of group.hooks) {
+                if (!isRecord(h))
+                    continue;
+                const entry = {
+                    event,
+                    type: stringField(h, "type") || "command",
+                    command: stringField(h, "command") || stringField(h, "prompt") || stringField(h, "url"),
+                    source,
+                    sourcePath,
+                    active: true,
+                };
+                const matcher = stringField(group, "matcher");
+                if (matcher)
+                    entry.matcher = matcher;
+                if (plugin)
+                    entry.plugin = plugin.id;
+                out.push(entry);
+            }
+        }
+    }
+    return out;
+}