skillcellar 0.6.0 → 0.7.0

package/README.md

@@ -4,7 +4,7 @@ Keeps your [SkillCellar](https://skillcellar.com) library's list of what a compu
 
 1. Create an API key at https://skillcellar.com/dashboard/keys, one per computer.
 2. `npx skillcellar login`: paste the key, then choose which of your devices this computer is, or name a new one. `--device <name>` chooses without asking. It then offers to install the skillcellar skill for Claude Code, in `~/.claude/skills/skillcellar`.
-3. `npx skillcellar sync`: reports the whole computer in one request: what it has globally, then every project Claude Code knows. Each sync replaces what the last one reported from this computer, so a project you deleted, or one Claude Code no longer lists, leaves this computer's list on the site, and the site once no computer has anything in it; marks you once made by hand on the site stay. `--project <name>`, run inside a project's folder, reports only that project (every checkout of it Claude Code knows) and global, under that name, and leaves the others as they are. `--dry-run` prints what would be sent and sends nothing. The site then closes the tasks it finds done, and the sync lists them.
+3. `npx skillcellar sync`: reports the whole computer in one request: what it has globally, then every project Claude Code knows, and every clone a restore wrote into. Each sync replaces what the last one reported from this computer, so a project you deleted, or one Claude Code no longer lists, leaves this computer's list on the site, and the site once no computer has anything in it; marks you once made by hand on the site stay. `--project <name>`, run inside a project's folder, reports only that project (every checkout of it Claude Code knows) and global, under that name, and leaves the others as they are. `--dry-run` prints what would be sent and sends nothing. The site then closes the tasks it finds done, and the sync lists them.
 
 ## Tasks
 
@@ -29,20 +29,22 @@ Both read this computer as `sync` does and send that list as `sync` sends it (na
 
 ## Backups
 
-`skillcellar backup --repo <owner>/<repo>` pushes this computer's Claude Code setup to a private GitHub repository you own, with your own git and its credentials, under `devices/<device>/`: `global/` holds your skills' source files, `CLAUDE.md`, `rules/`, `agents/` and `mcp.json`; `projects/<project>/` holds the same for each project, with its `AGENTS.md`, the session memory Claude Code keeps for it under `memory/`, and its MCP servers in `mcp.json` (the project's `.mcp.json`) and `mcp.local.json` (those Claude Code keeps for its folders). A `manifest.json` names the device and its projects. The repository is remembered, so `skillcellar backup` alone works from then on; `--ssh` clones and pushes over SSH, and `--dry-run` lists what would go without cloning, committing or pushing.
+To move to a new computer, or back onto one you reinstall, follow the step-by-step guide at https://skillcellar.com/guides/new-computer.
+
+`skillcellar backup --repo <owner>/<repo>` pushes this computer's Claude Code setup to a private GitHub repository you own, with your own git and its credentials, under `devices/<device>/`: `global/` holds your skills' source files, `CLAUDE.md`, `rules/`, `agents/` and `mcp.json`; `projects/<project>/` holds the same for each project, with its `AGENTS.md`, the session memory Claude Code keeps for it under `memory/`, and its MCP servers in `mcp.json` (the project's `.mcp.json`) and `mcp.local.json` (those Claude Code keeps for its folders). A project checked out more than once on the computer is one project, as on the site: every checkout goes in its one folder, and where two hold a file or a skill of the same name, the one the sync sends first goes and the other is listed as left out. MCP servers of the same name are kept once the same way, but separately in `mcp.json` and in `mcp.local.json`, and the one left out is not listed. A `manifest.json` names the device and its projects. The repository is remembered, so `skillcellar backup` alone works from then on; `--ssh` clones and pushes over SSH, and `--dry-run` lists what would go without cloning, committing or pushing.
 
 - In the MCP config every `env` and header value, an address's credentials and its query's values, the parts of its path that are not short words, and an argument that looks like a key are replaced by a placeholder, named after its key where one exists (`${CONTEXT7_KEY}`), else `${ARG_n}` or `${PATH_n}`. A key of a shape the check does not know, in another field, or given as a bare argument shorter than 16 characters, stays: read the backup once before you rely on it.
 - Source files are text of a known kind (Markdown, code, JSON, YAML and the like) under 1 MB. Folders of installed packages, caches and build output (`node_modules`, `vendor`, `.venv`, `venv`, `env`, `__pycache__`, `.git`, `.cache`, `.next`, `.turbo`, `.nuxt`, `.svelte-kit`, `dist`, `build`, `target`, `coverage`, `.tox`, `.mypy_cache`, `.pytest_cache`, `.ruff_cache`, `.gradle` and `ms-playwright`) are left out at any depth, as are links inside a skill folder, and the command lists the folders and files it left out for those reasons, a file over 1 MB and a folder it could not read among them. Files a project's own git tracks are left out without a line: a clone brings them.
-- Before anything is pushed, every file is read for what looks like a key, a token, a password or a private key: known shapes (GitHub, OpenAI, AWS, Stripe, Slack, Google, npm, Neon, Resend, Hugging Face, Groq, JSON Web Tokens, private key blocks), a password in an address, a bearer or basic credential, and a name such as `API_KEY`, `password` or `token` assigned a value with digits in it. Anything found stops the backup with each file and line (the first 20), and nothing is pushed. A file you have read and know holds no secret goes through with `--allow <path>` for that file. Then the repository is checked without a token: one that answers anyone is public, and is refused. The clone lives beside the config, in `skillcellar/backups/<owner>/<repo>`, readable by you only; each backup brings the clone to the remote's state, commits and pushes, and a commit a failed push left behind goes with the next run.
+- Before anything is pushed, every file is read for what looks like a key, a token, a password or a private key: known shapes (GitHub, OpenAI, AWS, Stripe, Slack, Google, npm, Neon, Resend, Hugging Face, Groq, JSON Web Tokens, private key blocks), a password in an address, a bearer or basic credential, and a name such as `API_KEY`, `password` or `token` assigned a value with digits in it; neither of the last two counts when the value is elided (`abc123...`) or holds an example word (`dummy`, `fake`, `sample`, `example`, `placeholder`, `redacted` or `changeme`) in any case with no letter next to it; an assignment whose value starts with `example`, `placeholder`, `redacted` or `changeme` is passed whatever follows. An assignment does not count either when its value is unquoted and is a dotted name directly followed by `(`, such as `base64.b64encode(`. Anything found stops the backup with each file and line (the first 20), and nothing is pushed. A file you have read and know holds no secret goes through with `--allow <path>` for that file, and each run lists the files it lets through this way. A backup that pushes remembers each with the hash of its contents, so later runs pass it without `--allow` until it changes, and names it in `manifest.json`, so a restore copies it as it was allowed. Then the repository is checked without a token: one that answers anyone is public, and is refused. The clone lives beside the config, in `skillcellar/backups/<owner>/<repo>`, readable by you only; each backup brings the clone to the remote's state, commits and pushes, and a commit a failed push left behind goes with the next run.
 - The site learns only the repository's name, the commit and the time, which the device's page shows. It holds no token for the repository and never reads the backup.
 
-`skillcellar restore` carries out the copy tasks waiting for this computer ("Copy to…" on the compare page, or "Copy everything to…" on a device's page). The site names the other computer's backup repository and commit, and a name is not proof: the restore takes a repository this computer does not itself back up to only with `--repo <owner>/<repo>`, or a yes at the terminal, and refuses a public one. It fetches the backup into a bare mirror beside the config (`skillcellar/backups/<owner>/<repo>.git`, never checked out, so a link in the repository is never followed), reads the commit the site recorded, and writes its skills, memory files and agents into place: a memory file or agent only when its hash is the one the other computer reported, where it reported one, nothing that holds what looks like a secret, nothing over the skillcellar skill, nothing over a file that is a link, and nothing into a project's `.claude`, `.claude/skills`, `.claude/agents` or `.claude/rules` when that folder is a link; what is there already stays unless you pass `--force`, which replaces every item the tasks name. It prints the commands left: a plugin's install, `npx skills add` for a skill from a repository, and `claude mcp add-json` for each MCP server with the backup's config, where each `${NAME}` is yours to fill in, and a `review` note marks a `${VAR:-default}` or `$VAR` reference or a `headersHelper` to read before adding. It also names the `package.json`, `requirements.txt`, `pyproject.toml` or Playwright config a restored skill carries, so you can rebuild its environment. `--from <device>` takes one computer's tasks; `--ssh` fetches over SSH; `--dry-run` fetches the backup but writes nothing into place. The printed commands are quoted for a POSIX shell; on Windows, paste them into Git Bash or WSL. Then `skillcellar sync` closes each task this computer now satisfies.
+`skillcellar restore` carries out the copy tasks waiting for this computer ("Copy to…" on the compare page, or "Copy everything to…" on a device's page). The site names the other computer's backup repository and commit, and a name is not proof: the restore takes a repository this computer does not itself back up to only with `--repo <owner>/<repo>`, or a yes at the terminal, and refuses a public one. It fetches the backup into a bare mirror beside the config (`skillcellar/backups/<owner>/<repo>.git`, never checked out, so a link in the repository is never followed), reads the commit the site recorded, and writes its skills, memory files and agents into place: a memory file or agent only when its hash is the one the other computer reported, where it reported one, unless you pass `--take-backup`, which copies the backup's copy and says so; nothing that holds what looks like a secret unless the backup's `manifest.json` names the file as allowed with those very contents, nothing over the skillcellar skill, nothing over a file that is a link, and nothing into a project's `.claude`, `.claude/skills`, `.claude/agents` or `.claude/rules` when that folder is a link. What is there already stays unless you pass `--force`, which replaces every item the tasks name: one the same as the backup's copy is only counted, one that differs is named, and a skill folder without its SKILL.md, which an antivirus can leave behind, is named as no skill rather than kept. A copy of everything in a place also lists what the backup holds there that the other computer's last sync did not report, such as a memory file written after that sync; `--take-backup` copies those too. It prints the commands left: a plugin's install, `npx skills add` for a skill from a repository, under the name the skill's SKILL.md gives in the backup and with `-g -y` for a global task, and `claude mcp add-json` for each MCP server with the backup's config, where each `${NAME}` is yours to fill in, and a `review` note marks a `${VAR:-default}` or `$VAR` reference or a `headersHelper` to read before adding. `--from-backup <skill>` copies a skill's files from the backup instead of printing its command, for a skill that has left its repository; a plugin whose marketplace renamed itself since installs under the name `/plugin marketplace list` shows. It also names the `package.json`, `requirements.txt`, `pyproject.toml` or Playwright config a restored skill carries, so you can rebuild its environment. `--from <device>` takes one computer's tasks; `--ssh` fetches over SSH, and a fetch over HTTPS that git has no credentials for says to add it; `--dry-run` fetches the backup but writes nothing into place. The printed commands are quoted for a POSIX shell; on Windows, paste them into Git Bash or WSL. Each project folder it restores is remembered in the config, so `sync`, `plan` and `backup` read it from then on, as if Claude Code had been opened there. Then `skillcellar sync` closes each task this computer now satisfies.
 
 ## What it reads
 
 Globally, in `~/.claude`:
 
-- `skills`: each folder with a SKILL.md, skipping `learned`, `synced`, hidden and `*-workspace` folders, and skills nested deeper; and the lock where `npx skills` records each skill's repository, folder and hash: `$XDG_STATE_HOME/skills/.skill-lock.json` when that variable is set, else `~/.agents/.skill-lock.json`.
+- `skills`: each folder with a SKILL.md of its own, whatever its name, skipping `learned`, `synced` and hidden folders, and skills nested deeper, such as in skill-creator's `*-workspace` folders; and the lock where `npx skills` records each skill's repository, folder and hash: `$XDG_STATE_HOME/skills/.skill-lock.json` when that variable is set, else `~/.agents/.skill-lock.json`.
 - `plugins/installed_plugins.json` and `known_marketplaces.json`: the plugins Claude Code lists as installed, and their marketplaces.
 - `CLAUDE.md`, `rules/**/*.md` and `agents/**/*.md`.
 - `~/.claude.json`: your MCP servers (`mcpServers`), and the projects Claude Code knows (`projects`), with their own MCP servers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillcellar",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Sync what Claude Code has on this computer (skills, plugins, MCP servers, memory and agents) to your SkillCellar library, by name and hash, list the tasks you queue there for Claude Code to carry out, check which skills and plugins are outdated, and apply playbooks.",
   "keywords": [
     "claude-code",

package/skill/SKILL.md

@@ -61,9 +61,9 @@ A removal deletes something from this computer. Show the user exactly what goes,
 
 ## 4. Copy
 
-A copy brings what another of the user's computers has, in the same place, from that computer's backup, a private GitHub repository the user owns. The site only names that repository, and a name is not proof: show the user `copy.from.device.name` and `copy.from.backup.repo`, and run the restore only once they confirm the repository is theirs, as `npx skillcellar restore --repo <owner>/<repo>` with the name they confirmed (`--from <device>` takes one computer's tasks; on a computer that backs up to the same repository, `npx skillcellar restore` alone works). For a project task, run it from inside the project's folder on this computer, cloned first if it is not there yet. It refuses a public repository, fetches the backup into the tool's own folder with the user's own git, reads the commit the site recorded, writes skills, memory files and agents into place, keeps a folder or file that is there already, and prints the rest as commands. If it says a folder is there already, ask the user whether to replace it, and run it again with `--force` only on a yes: `--force` replaces every item it names, so tell the user which. If it says there is no backup yet, or that the commit is missing, tell the user to run `npx skillcellar backup` on the other computer, and go on with the next task.
+A copy brings what another of the user's computers has, in the same place, from that computer's backup, a private GitHub repository the user owns. The site only names that repository, and a name is not proof: show the user `copy.from.device.name` and `copy.from.backup.repo`, and run the restore only once they confirm the repository is theirs, as `npx skillcellar restore --repo <owner>/<repo>` with the name they confirmed (`--from <device>` takes one computer's tasks; on a computer that backs up to the same repository, `npx skillcellar restore` alone works). For a project task, run it from inside the project's folder on this computer, cloned first if it is not there yet. It refuses a public repository, fetches the backup into the tool's own folder with the user's own git, reads the commit the site recorded, writes skills, memory files and agents into place, keeps a folder or file that is there already, and prints the rest as commands. If it says a folder is there already, ask the user whether to replace it, and run it again with `--force` only on a yes: `--force` replaces every item it names, so tell the user which. If it says a skill's folder has no SKILL.md, an antivirus may have removed it: tell the user, and copy it again with `--force` only on their yes. If it says the backup's copy of a file is not the one the other computer last reported, or lists what the backup holds that its last sync did not report, show the user and run it again with `--take-backup` only on their yes. If it says there is no backup yet, or that the commit is missing, tell the user to run `npx skillcellar backup` on the other computer, and go on with the next task.
 
-The commands it prints run each inside the folder of its task. A plugin's or a repository skill's install command is plain, as section 2 says. A `claude mcp add-json <name> '<json>' --scope <scope>` command is never plain: it adds a server that starts with every Claude Code session, with the backup's config, so show the user its full JSON (the command, its arguments, the address, the headers) and run it only on their yes to that server. A `${NAME}` in that config marks a value the backup left out, such as a key or an environment variable, and a command marked `review` holds a `${VAR:-default}` or `$VAR` reference that reaches into the user's environment, or a `headersHelper` command: both go to the user, as section 2 says, and you never fill a placeholder in. An item marked `tracked` comes with the project's repository: pull it, and copy nothing.
+The commands it prints run each inside the folder of its task. A plugin's or a repository skill's install command is plain, as section 2 says; a global `npx skills add` from `restore` carries `-g -y` already, so add only `--agent claude-code`. If it finds no matching skill, the skill has left its repository: ask the user, and on a yes run the restore again with `--from-backup <name>`, which copies the backup's copy instead. If `/plugin install` says the plugin is not in its marketplace, run `/plugin marketplace list` and install it under the name shown there for that marketplace. A `claude mcp add-json <name> '<json>' --scope <scope>` command is never plain: it adds a server that starts with every Claude Code session, with the backup's config, so show the user its full JSON (the command, its arguments, the address, the headers) and run it only on their yes to that server. A `${NAME}` in that config marks a value the backup left out, such as a key or an environment variable, and a command marked `review` holds a `${VAR:-default}` or `$VAR` reference that reaches into the user's environment, or a `headersHelper` command: both go to the user, as section 2 says, and you never fill a placeholder in. An item marked `tracked` comes with the project's repository: pull it, and copy nothing.
 
 A restored skill may need its environment: `restore` names each `package.json` (`npm install`), `requirements.txt` (`pip install -r requirements.txt`), `pyproject.toml` or Playwright config it found. Each of those is a package manager's install, so show it to the user and run it only after their yes to that command, inside the skill's folder.
 

package/src/backup.mjs

@@ -1,10 +1,11 @@
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import { lstat, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { dirname, extname, join, relative } from "node:path";
 import { configPath } from "./config.mjs";
 import { markdownFiles } from "./files.mjs";
 import { sessionFolderName } from "./places.mjs";
-import { projectSlug } from "./plan.mjs";
+import { projectIdentity, projectSlug } from "./plan.mjs";
 import { skillFolders } from "./scan.mjs";
 import { findSecret } from "./secrets.mjs";
 
@@ -287,6 +288,7 @@ const sanitizeServers = (servers) => Object.fromEntries(Object.entries(servers ?
 // ── What a device backs up ──────────────────────────────────────────────────────────────────
 
 const text = (path, source, content) => ({ path, source, content: Buffer.from(content), executable: false });
+const manifestFile = (base, manifest) => text(`${base}/manifest.json`, "manifest", `${JSON.stringify(manifest, null, 2)}\n`);
 
 /** The `.md` files of a folder, for the backup, as `<into>/<path>`; a folder's absence is nothing to back up, one that cannot be read is named. */
 async function markdownInto(dir, into, own, skipped) {
@@ -362,71 +364,111 @@ export async function collectBackup({ device, claudeDir, claudeJson, projects, t
   if (Object.keys(globalServers).length) files.push(text(`${base}/global/mcp.json`, "~/.claude.json (mcpServers)", `${JSON.stringify({ mcpServers: globalServers }, null, 2)}\n`));
 
   const places = [{ folder: "global", files: files.length }];
-  const projectFolders = new Set();
+  // Every checkout of one project, such as two clones of a repository, goes in the project's one
+  // folder, as the site merges them into one project. Another project whose name makes the same
+  // folder name is left out.
+  const groups = new Map();
   for (const project of projects) {
     const slug = projectSlug(project, device.slug);
     if (!slug) continue;
-    if (projectFolders.has(slug)) {
-      skipped.push({ path: project.root, reason: `a folder of the same name, ${slug}, is backed up already` });
-      continue;
-    }
-    projectFolders.add(slug);
+    const group = groups.get(slug);
+    if (!group) groups.set(slug, [project]);
+    else if (projectIdentity(group[0]) === projectIdentity(project)) group.push(project);
+    else skipped.push({ path: project.root, reason: `a folder of the same name, ${slug}, is backed up already` });
+  }
+  for (const [slug, group] of groups) {
+    // In the order the sync sends them, which the site merges them in: by name, then as found.
+    const checkouts = [...group].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     const into = `${base}/projects/${slug}`;
-    const own = { root: project.root, tracked: await trackedOf(project.root) };
     const before = files.length;
-    files.push(...(await skillsInto(join(project.root, ".claude", "skills"), `${into}/skills`, own, skipped, budget)));
-    files.push(...(await oneFile(join(project.root, "CLAUDE.md"), `${into}/CLAUDE.md`, own, skipped)));
-    files.push(...(await oneFile(join(project.root, "AGENTS.md"), `${into}/AGENTS.md`, own, skipped)));
-    files.push(...(await markdownInto(join(project.root, ".claude", "rules"), `${into}/rules`, own, skipped)));
-    files.push(...(await markdownInto(join(project.root, ".claude", "agents"), `${into}/agents`, own, skipped)));
-    const seen = new Set();
-    for (const folder of new Set([project.root, ...(project.folders ?? [])])) {
-      for (const file of await markdownInto(join(claudeDir, "projects", sessionFolderName(folder), "memory"), `${into}/memory`, null, skipped)) {
-        if (seen.has(file.path)) continue;
-        seen.add(file.path);
-        files.push(file);
+    // The first checkout's item of a name wins, as on the site: a file by its path, a skill by its whole folder.
+    const item = (path) => (path.startsWith(`${into}/skills/`) ? path.split("/", into.split("/").length + 2).join("/") : path);
+    const taken = new Set();
+    const shared = new Map();
+    const local = new Map();
+    const sharedSources = [];
+    for (const project of checkouts) {
+      const own = { root: project.root, tracked: await trackedOf(project.root) };
+      const found = [
+        ...(await skillsInto(join(project.root, ".claude", "skills"), `${into}/skills`, own, skipped, budget)),
+        ...(await oneFile(join(project.root, "CLAUDE.md"), `${into}/CLAUDE.md`, own, skipped)),
+        ...(await oneFile(join(project.root, "AGENTS.md"), `${into}/AGENTS.md`, own, skipped)),
+        ...(await markdownInto(join(project.root, ".claude", "rules"), `${into}/rules`, own, skipped)),
+        ...(await markdownInto(join(project.root, ".claude", "agents"), `${into}/agents`, own, skipped)),
+      ];
+      const seen = new Set();
+      for (const folder of new Set([project.root, ...(project.folders ?? [])])) {
+        for (const file of await markdownInto(join(claudeDir, "projects", sessionFolderName(folder), "memory"), `${into}/memory`, null, skipped)) {
+          if (seen.has(file.path)) continue;
+          seen.add(file.path);
+          found.push(file);
+        }
       }
-    }
-    if (!own.tracked.has(".mcp.json")) {
-      const mcpJson = await readFile(join(project.root, ".mcp.json"), "utf8").catch(() => null);
-      let servers = null;
-      try {
-        servers = mcpJson === null ? null : JSON.parse(mcpJson)?.mcpServers;
-      } catch {
-        skipped.push({ path: join(project.root, ".mcp.json"), reason: "not valid JSON" });
+      const lost = new Map();
+      for (const file of found) {
+        const key = item(file.path);
+        if (!taken.has(key)) files.push(file);
+        else if (!lost.has(key)) lost.set(key, key.startsWith(`${into}/skills/`) ? join(project.root, ".claude", "skills", key.slice(`${into}/skills/`.length)) : file.source);
       }
-      if (servers && typeof servers === "object" && Object.keys(servers).length) {
-        files.push(text(`${into}/mcp.json`, join(project.root, ".mcp.json"), `${JSON.stringify({ mcpServers: sanitizeServers(servers) }, null, 2)}\n`));
+      for (const path of lost.values()) skipped.push({ path, reason: `another checkout of ${project.name} has one of the same name, backed up instead, as the site keeps one` });
+      for (const file of found) taken.add(item(file.path));
+      if (!own.tracked.has(".mcp.json")) {
+        const mcpJson = await readFile(join(project.root, ".mcp.json"), "utf8").catch(() => null);
+        let servers = null;
+        try {
+          servers = mcpJson === null ? null : JSON.parse(mcpJson)?.mcpServers;
+        } catch {
+          skipped.push({ path: join(project.root, ".mcp.json"), reason: "not valid JSON" });
+        }
+        if (servers && typeof servers === "object" && Object.keys(servers).length) {
+          sharedSources.push(join(project.root, ".mcp.json"));
+          for (const [name, server] of Object.entries(sanitizeServers(servers))) if (!shared.has(name)) shared.set(name, server);
+        }
       }
+      const ownLocal = {};
+      for (const folder of [project.root, ...(project.folders ?? [])]) Object.assign(ownLocal, sanitizeServers(claudeJson?.projects?.[folder]?.mcpServers));
+      for (const [name, server] of Object.entries(ownLocal)) if (!local.has(name)) local.set(name, server);
     }
-    const local = {};
-    for (const folder of [project.root, ...(project.folders ?? [])]) Object.assign(local, sanitizeServers(claudeJson?.projects?.[folder]?.mcpServers));
-    if (Object.keys(local).length) files.push(text(`${into}/mcp.local.json`, `~/.claude.json (projects, mcpServers)`, `${JSON.stringify({ mcpServers: local }, null, 2)}\n`));
+    if (shared.size) files.push({ ...text(`${into}/mcp.json`, sharedSources.join(", "), `${JSON.stringify({ mcpServers: Object.fromEntries(shared) }, null, 2)}\n`), sources: sharedSources });
+    if (local.size) files.push(text(`${into}/mcp.local.json`, `~/.claude.json (projects, mcpServers)`, `${JSON.stringify({ mcpServers: Object.fromEntries(local) }, null, 2)}\n`));
+    const [project] = checkouts;
     places.push({ folder: `projects/${slug}`, name: project.name, repo: project.repo ?? null, remote: Boolean(project.remote), files: files.length - before });
   }
 
   // No time in the manifest: the commit carries it, and an unchanged computer then commits nothing.
   const manifest = { skillcellar: version, device: { id: device.id, slug: device.slug, name: device.name }, places };
-  files.push(text(`${base}/manifest.json`, "manifest", `${JSON.stringify(manifest, null, 2)}\n`));
+  files.push(manifestFile(base, manifest));
   return { files, skipped, manifest };
 }
 
 // How many findings a stopped backup lists.
 const FINDINGS_MAX = 20;
 
+/** A path with `/` between its folders, as on Windows `--allow` may name a file either way. */
+const slashed = (path) => path.replaceAll("\\", "/");
+
 /**
- * The files of a backup that hold what looks like a secret, each with the line, up to FINDINGS_MAX;
- * a file the user allowed by its path, or the end of it, is not read.
+ * The files of a backup that hold what looks like a secret, each with the line, up to FINDINGS_MAX,
+ * and those that pass despite one, each with the hash of what passed: a file the user allows by its
+ * path, whole or from a folder's start, and one an earlier backup let through holding these bytes.
  */
-export function findSecretsIn(files, allowed = []) {
+export function findSecretsIn(files, allowed = [], remembered = []) {
   const findings = [];
+  const passed = [];
   for (const file of files) {
-    if (allowed.some((path) => file.source === path || file.source.endsWith(`/${path}`))) continue;
     const found = findSecret(file.content.toString("utf8"));
-    if (found) findings.push({ ...found, file: file.source });
+    if (!found) continue;
+    const sha256 = createHash("sha256").update(file.content).digest("hex");
+    // A merged file, such as the mcp.json of several checkouts, is allowed by any file it came from.
+    const names = (file.sources ?? [file.source]).map(slashed);
+    if (allowed.map(slashed).some((path) => names.some((name) => name === path || name.endsWith(`/${path}`))) || remembered.some((entry) => entry?.file === file.source && entry.sha256 === sha256)) {
+      passed.push({ file: file.source, path: file.path, sha256, line: found.line, kind: found.kind });
+      continue;
+    }
+    findings.push({ ...found, file: file.source });
     if (findings.length >= FINDINGS_MAX) break;
   }
-  return findings;
+  return { findings, passed };
 }
 
 /** Writes the backup's files into the clone, replacing the device's folder and any older folder of the same device under another slug. */
@@ -462,6 +504,14 @@ export async function currentBranch(clone) {
   return head.trim() ? ref.trim() || null : null;
 }
 
+// What git says when it has no credentials for a GitHub repository over HTTPS.
+const HTTPS_AUTH_RE = /could not read Username|Authentication failed|terminal prompts disabled|Invalid username or password|repository '[^']*' not found/i;
+
+/** Git's failure to reach the backup repository, naming the way out when HTTPS had no credentials: SSH. */
+export function reachError(error, repo) {
+  return !repo.ssh && HTTPS_AUTH_RE.test(error.message) ? new Error(`${error.message}. If your GitHub access is an SSH key, run it again with --ssh.`) : error;
+}
+
 /**
  * The clone of the backup repository, made if missing, else brought to the remote's state: the
  * clone is the tool's own scratch area, so what a failed run left in its tree is dropped, a commit a
@@ -470,13 +520,16 @@ export async function currentBranch(clone) {
 export async function ensureClone(repo) {
   const clone = clonePath(repo.owner, repo.repo);
   const there = await stat(join(clone, ".git")).catch(() => null);
+  const reach = (error) => {
+    throw reachError(error, repo);
+  };
   if (!there?.isDirectory()) {
     await mkdir(dirname(clone), { recursive: true, mode: 0o700 });
-    await git(["clone", "--quiet", repo.url, clone], { timeout: 600_000 });
+    await git(["clone", "--quiet", repo.url, clone], { timeout: 600_000 }).catch(reach);
     return clone;
   }
   await git(["remote", "set-url", "origin", repo.url], { cwd: clone });
-  await git(["fetch", "--quiet", "origin"], { cwd: clone, timeout: 600_000 });
+  await git(["fetch", "--quiet", "origin"], { cwd: clone, timeout: 600_000 }).catch(reach);
   const branch = await currentBranch(clone);
   if (branch) {
     await git(["reset", "--hard", "--quiet"], { cwd: clone });
@@ -494,13 +547,16 @@ export async function ensureClone(repo) {
 export async function ensureMirror(repo) {
   const mirror = `${clonePath(repo.owner, repo.repo)}.git`;
   const there = await stat(join(mirror, "HEAD")).catch(() => null);
+  const reach = (error) => {
+    throw reachError(error, repo);
+  };
   if (!there?.isFile()) {
     await mkdir(dirname(mirror), { recursive: true, mode: 0o700 });
-    await git(["clone", "--quiet", "--bare", repo.url, mirror], { timeout: 600_000 });
+    await git(["clone", "--quiet", "--bare", repo.url, mirror], { timeout: 600_000 }).catch(reach);
     return mirror;
   }
   await git(["--git-dir", mirror, "remote", "set-url", "origin", repo.url]);
-  await git(["--git-dir", mirror, "fetch", "--quiet", "origin", "+refs/heads/*:refs/heads/*"], { timeout: 600_000 });
+  await git(["--git-dir", mirror, "fetch", "--quiet", "origin", "+refs/heads/*:refs/heads/*"], { timeout: 600_000 }).catch(reach);
   return mirror;
 }
 
@@ -514,14 +570,27 @@ export function describeSkipped(skipped) {
 
 const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
 
+/** The files let through despite a finding, as lines a person reads, so an allowance is never silent. */
+function describePassed(passed) {
+  if (!passed.length) return [];
+  return ["Let through as you allowed them:", ...passed.map(({ file, line, kind }) => `  ${file}:${line} looks like ${kind}`)];
+}
+
 /**
  * Backs up the device: collects its files, stops on anything that looks like a secret, refuses a
  * public repository, then commits and pushes with the user's own git. Answers what to print and the
  * commit to report, or null when nothing changed.
  */
-export async function runBackup({ repo, device, claudeDir, claudeJson, projects, trackedOf, version, dryRun, allowed = [], print, onPushed = async () => {} }) {
-  const { files, skipped, manifest } = await collectBackup({ device, claudeDir, claudeJson, projects, trackedOf, version });
-  const findings = findSecretsIn(files, allowed);
+export async function runBackup({ repo, device, claudeDir, claudeJson, projects, trackedOf, version, dryRun, allowed = [], remembered = [], print, onPushed = async () => {} }) {
+  const collected = await collectBackup({ device, claudeDir, claudeJson, projects, trackedOf, version });
+  const { skipped } = collected;
+  const { findings, passed } = findSecretsIn(collected.files, allowed, remembered);
+  // What passed despite a finding is named in the manifest with the hash of what passed, so a
+  // restore copies that and reads any other copy of the file again.
+  const base = `devices/${device.slug}`;
+  const allowedFiles = passed.map(({ path, sha256 }) => ({ path: path.slice(base.length + 1), sha256 })).sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  const manifest = allowedFiles.length ? { ...collected.manifest, allowed: allowedFiles } : collected.manifest;
+  const files = allowedFiles.length ? collected.files.map((file) => (file.path === `${base}/manifest.json` ? manifestFile(base, manifest) : file)) : collected.files;
   if (findings.length) {
     const lines = findings.map((found) => `  ${found.file}:${found.line} looks like ${found.kind}`);
     throw new Error(
@@ -532,7 +601,7 @@ export async function runBackup({ repo, device, claudeDir, claudeJson, projects,
   const summary = `${plural(files.length, "file")} (${size(bytes)}): ${manifest.places.map((place) => `${place.folder} ${place.files}`).join(", ")}`;
   if (dryRun) {
     print(`Would back up ${device.name} to ${repo.name}, ${summary}.`);
-    for (const line of describeSkipped(skipped)) print(line);
+    for (const line of [...describeSkipped(skipped), ...describePassed(passed)]) print(line);
     return null;
   }
   await refusePublic(repo, version);
@@ -548,10 +617,10 @@ export async function runBackup({ repo, device, claudeDir, claudeJson, projects,
   if (await currentBranch(clone)) {
     await git(["push", "--quiet", "-u", "origin", "HEAD"], { cwd: clone, timeout: 600_000 });
     commit = (await git(["rev-parse", "HEAD"], { cwd: clone })).trim();
-    await onPushed(commit);
+    await onPushed(commit, passed);
   }
   if (changed) print(`Backed up ${device.name} to ${repo.name} at ${commit.slice(0, 7)}, ${summary}.`);
   else print(`Nothing changed since the last backup of ${device.name} in ${repo.name}${commit ? ` (${commit.slice(0, 7)})` : ""}.`);
-  for (const line of describeSkipped(skipped)) print(line);
+  for (const line of [...describeSkipped(skipped), ...describePassed(passed)]) print(line);
   return commit;
 }

package/src/cli.mjs

@@ -7,7 +7,7 @@ import { parseBackupRepo, runBackup } from "./backup.mjs";
 import { describeCheck } from "./check.mjs";
 import { configPath, readConfig, writeConfig } from "./config.mjs";
 import { findProjects } from "./places.mjs";
-import { describePlan, localPlan } from "./plan.mjs";
+import { describePlan, localPlan, projectIdentity } from "./plan.mjs";
 import { applyPlaybook, cautionLine, describeStatus, readPlaybook } from "./playbook.mjs";
 import { findProject, trackedFiles } from "./project.mjs";
 import { ask, askSecret, firstLine, interactive } from "./prompt.mjs";
@@ -68,13 +68,19 @@ Usage:
       address credential and key-like argument replaced by a \${NAME} placeholder) and skills'
       source files to a private GitHub repository you own, with your own git. It stops on anything
       that looks like a secret and refuses a public repository. --repo is remembered; --ssh clones
-      and pushes over SSH; --allow <file> pushes a file you have read despite a finding in it;
-      --dry-run lists what would go.
-  skillcellar restore [--from <device>] [--repo <owner>/<repo>] [--ssh] [--force] [--dry-run]
+      and pushes over SSH; --allow <file> pushes a file you have read despite a finding in it,
+      and once pushed is remembered while the file stays the same; --dry-run lists what would go.
+  skillcellar restore [--from <device>] [--repo <owner>/<repo>] [--ssh] [--force] [--take-backup]
+                     [--from-backup <skill>] [--dry-run]
       Carry out the copy tasks waiting for this computer: fetch the other computer's backup, write
       its skills, memory files and agents into place, and list the commands left to run. A backup
       in a repository this computer does not back up to is taken only with --repo, or a yes at the
-      terminal. --force replaces a folder or file that is there already.
+      terminal. Each project folder it restores is remembered, so sync reports it from then on.
+      --force           replace a folder or file that is there already
+      --take-backup     copy a file whose backup copy is not the one the other computer last
+                        reported, and what the backup holds that its last sync did not report
+      --from-backup <skill>  copy this skill from the backup instead of printing its install
+                        command, for one that has left its repository
 
 login reads the key from SKILLCELLAR_API_KEY when it is set, else from the terminal or the first
 line piped in. The key and the device are kept in ${configPath()}, written with mode 0600.`;
@@ -159,10 +165,11 @@ async function login(flags, print) {
   if (!/^[A-Za-z0-9_]{1,200}$/.test(key)) throw new Error(`That is not an API key. Create one at ${site}/dashboard/keys.`);
   const library = await call(site, key, "GET", "/api/v1/library", undefined, VERSION);
   const device = flags.device !== undefined ? await namedDevice(site, key, flags.device) : await chooseDevice(site, key, library.devices ?? [], print);
-  // A backup repository remembered for this site stays remembered across sign-ins.
+  // A backup repository remembered for this site stays remembered across sign-ins, and the folders a restore wrote into always.
   const earlier = await readConfig().catch(() => null);
   const backup = earlier?.site === site && earlier.backup ? { backup: earlier.backup } : {};
-  await writeConfig({ site, key, device: { id: device.id, slug: device.slug, name: device.name }, ...backup });
+  const folders = Array.isArray(earlier?.folders) ? { folders: earlier.folders } : {};
+  await writeConfig({ site, key, device: { id: device.id, slug: device.slug, name: device.name }, ...backup, ...folders });
   const who = library.account?.email ? ` as ${library.account.email}` : "";
   print(`Signed in to ${new URL(site).host}${who}. This computer syncs as ${device.name}.`);
   await offerSkill(print);
@@ -202,9 +209,6 @@ function summary(payload, result, deviceName, whole) {
  */
 const claudeJsonPath = (home) => (process.env.CLAUDE_CONFIG_DIR?.trim() ? join(process.env.CLAUDE_CONFIG_DIR.trim(), ".claude.json") : join(home, ".claude.json"));
 
-/** What makes checkouts one project on the site: their GitHub repository, else their name. */
-const identity = (project) => project.repo ?? project.name.toLowerCase();
-
 /** The tasks a sync closed, in one line. */
 function closedLine(closed) {
   const verb = (task) => (task.action === "remove" ? "removed" : task.action === "copy" ? "copied" : "installed");
@@ -226,13 +230,13 @@ async function sync(flags, print, warn) {
   const claudeJson = (await readJson(claudeJsonPath(home))) ?? {};
   const cwd = process.cwd();
   const whole = flags.project === undefined;
-  let projects = await findProjects({ home, claudeDir, claudeJson, cwd });
+  let projects = await findProjects({ home, claudeDir, claudeJson, cwd, restored: config?.folders });
   if (!whole) {
     const here = await findProject(cwd, home);
     if (!here) throw new UsageError("Run sync --project inside the project's folder, not in your home folder.");
     if (!/[A-Za-z0-9]/.test(flags.project)) throw new UsageError("--project needs a letter a–z or a digit 0–9.");
     // Every checkout of the same repository is one project on the site, so all of them go together.
-    const same = projects.filter((known) => known.root === here.root || (here.remote && known.remote && identity(known) === identity(here)));
+    const same = projects.filter((known) => known.root === here.root || (here.remote && known.remote && projectIdentity(known) === projectIdentity(here)));
     projects = (same.length ? same : [{ ...here, folders: new Set([cwd]) }]).map((known) => ({ ...known, name: flags.project }));
   }
 
@@ -252,7 +256,7 @@ async function sync(flags, print, warn) {
     } catch (error) {
       // One project's broken file stops only that project in a sync of the whole computer.
       if (!whole) throw error;
-      unread.add(identity(project));
+      unread.add(projectIdentity(project));
       warn(`Not reported: ${project.name}, because ${error.message} The site keeps what it had there until a sync can read it.`);
       continue;
     }
@@ -266,7 +270,7 @@ async function sync(flags, print, warn) {
   // one as it was and closes no task there; an empty place is then sent, to empty it. Another
   // checkout of the unread project is left out too, or it would replace the project on its own.
   const complete = whole && !unread.size;
-  if (!complete) places = [...places, ...empty].filter((place) => !unread.has(identity(place.project)));
+  if (!complete) places = [...places, ...empty].filter((place) => !unread.has(projectIdentity(place.project)));
   if (places.length > PROJECTS_PER_SYNC) {
     throw new Error(`This computer has ${places.length} projects to send, and one sync takes ${PROJECTS_PER_SYNC}. Sync each one you need from its folder with --project <name>.`);
   }
@@ -303,7 +307,7 @@ async function plan(flags, print) {
   const answer = await call(site, config.key, "GET", `/api/v1/plan?device=${encodeURIComponent(config.device.id)}`, undefined, VERSION);
   const home = homedir();
   const claudeDir = claudeFolder(home);
-  const projects = (answer.tasks ?? []).some((task) => task.project) ? await knownProjects(home, claudeDir) : [];
+  const projects = (answer.tasks ?? []).some((task) => task.project) ? await knownProjects(home, claudeDir, config) : [];
   // The device's slug as the site has it now: a rename changes the slugs of its folders' projects.
   const local = await localPlan(answer, { claudeDir, projects, deviceSlug: answer.device?.slug ?? config.device.slug });
   if (flags.json) print(JSON.stringify(local, null, 2));
@@ -355,7 +359,7 @@ async function playbook(flags, action, ref, print, warn) {
   const claudeJson = (await readJson(claudeJsonPath(home))) ?? {};
   const global = await scanGlobal({ home, claudeDir, claudeJson });
   // The project as a sync reads it: every folder in it Claude Code ran in, as well as this one.
-  const known = here ? (await findProjects({ home, claudeDir, claudeJson, cwd: process.cwd() })).find((entry) => entry.root === here.root) : null;
+  const known = here ? (await findProjects({ home, claudeDir, claudeJson, cwd: process.cwd(), restored: config.folders })).find((entry) => entry.root === here.root) : null;
   const folders = here ? [...new Set([here.root, ...(known?.folders ?? []), process.cwd()])] : [];
   const project = here ? await scanProject({ root: here.root, folders, claudeDir, claudeJson, tracked: await trackedFiles(here.root) }) : null;
   const body = { ref, global: global.items, project: project?.items ?? null, updates: action === "status" };
@@ -387,8 +391,8 @@ async function playbook(flags, action, ref, print, warn) {
 }
 
 /** This computer's projects, as the sync finds them. */
-async function knownProjects(home, claudeDir) {
-  return findProjects({ home, claudeDir, claudeJson: (await readJson(claudeJsonPath(home))) ?? {}, cwd: process.cwd() });
+async function knownProjects(home, claudeDir, config) {
+  return findProjects({ home, claudeDir, claudeJson: (await readJson(claudeJsonPath(home))) ?? {}, cwd: process.cwd(), restored: config?.folders });
 }
 
 /**
@@ -413,11 +417,17 @@ async function backup(flags, print, warn) {
     ? ((await call(site, config.key, "GET", `/api/v1/plan?device=${encodeURIComponent(config.device.id)}`, undefined, VERSION)).device ?? config.device)
     : { id: null, slug: "this-computer", name: "this computer" };
   const claudeJson = (await readJson(claudeJsonPath(home))) ?? {};
-  const projects = await knownProjects(home, claudeDir);
+  const projects = await knownProjects(home, claudeDir, config);
   const allowed = (Array.isArray(flags.allow) ? flags.allow : []).map((path) => path.trim()).filter(Boolean);
-  // The repository is remembered as soon as a push has gone through, whatever the site answers after.
-  const remember = () => (config ? writeConfig({ ...config, device: { id: device.id, slug: device.slug, name: device.name }, backup: { repo: repo.name, ssh: repo.ssh } }) : Promise.resolve());
-  const commit = await runBackup({ repo, device, claudeDir, claudeJson, projects, trackedOf: trackedFiles, version: VERSION, dryRun, allowed, print, onPushed: remember });
+  // The repository is remembered as soon as a push has gone through, whatever the site answers after,
+  // with the files the user allowed despite a finding, each by the hash of what was allowed.
+  const remember = (commit, passed = []) => {
+    if (!config) return Promise.resolve();
+    const kept = passed.length ? { allowed: passed.map(({ file, sha256 }) => ({ file, sha256 })) } : {};
+    return writeConfig({ ...config, device: { id: device.id, slug: device.slug, name: device.name }, backup: { repo: repo.name, ssh: repo.ssh, ...kept } });
+  };
+  const remembered = Array.isArray(config?.backup?.allowed) ? config.backup.allowed : [];
+  const commit = await runBackup({ repo, device, claudeDir, claudeJson, projects, trackedOf: trackedFiles, version: VERSION, dryRun, allowed, remembered, print, onPushed: remember });
   if (dryRun || !commit) return;
   const recorded = await call(site, config.key, "POST", "/api/v1/backup", { device: device.id, repo: repo.name, commit }, VERSION);
   const slug = recorded.device?.slug ?? device.slug;
@@ -430,9 +440,13 @@ async function restore(flags, print, warn) {
   const home = homedir();
   const claudeDir = claudeFolder(home);
   const answer = await call(site, config.key, "GET", `/api/v1/plan?device=${encodeURIComponent(config.device.id)}`, undefined, VERSION);
-  const projects = (answer.tasks ?? []).some((task) => task.project) ? await knownProjects(home, claudeDir) : [];
+  const projects = (answer.tasks ?? []).some((task) => task.project) ? await knownProjects(home, claudeDir, config) : [];
   const plan = await localPlan(answer, { claudeDir, projects, deviceSlug: answer.device?.slug ?? config.device.slug });
-  await runRestore({ plan, claudeDir, config, flags, version: VERSION, print, warn });
+  const { folders } = await runRestore({ plan, claudeDir, config, flags, version: VERSION, print, warn });
+  // A clone Claude Code has not been opened in yet is otherwise one no sync reads, and its copy task would never close.
+  const remembered = Array.isArray(config.folders) ? config.folders : [];
+  const added = [...folders].filter((folder) => !remembered.includes(folder));
+  if (added.length) await writeConfig({ ...config, folders: [...remembered, ...added] });
 }
 
 /** Installs or updates the skillcellar skill without asking: the command itself is the yes. */
@@ -479,6 +493,8 @@ export async function main(argv, toOut = console.log, toErr = console.error) {
         repo: { type: "string" },
         ssh: { type: "boolean" },
         from: { type: "string" },
+        "take-backup": { type: "boolean" },
+        "from-backup": { type: "string", multiple: true },
         allow: { type: "string", multiple: true },
         help: { type: "boolean", short: "h" },
         version: { type: "boolean", short: "v" },

package/src/places.mjs

@@ -36,11 +36,12 @@ async function sessionFolder(dir) {
 }
 
 /**
- * Every folder Claude Code knows on this computer: the projects `~/.claude.json` lists, and the
- * folder each of `~/.claude/projects/*` ran in. Folders that are gone are skipped.
+ * Every folder Claude Code knows on this computer: the projects `~/.claude.json` lists, the folder
+ * each of `~/.claude/projects/*` ran in, and those a restore wrote into, which Claude Code may never
+ * have been opened in. Folders that are gone are skipped.
  */
-async function knownFolders(claudeDir, claudeJson) {
-  const folders = new Set(Object.keys(claudeJson?.projects ?? {}));
+async function knownFolders(claudeDir, claudeJson, restored) {
+  const folders = new Set([...Object.keys(claudeJson?.projects ?? {}), ...restored.filter((folder) => typeof folder === "string" && isAbsolute(folder))]);
   const sessions = join(claudeDir, "projects");
   const names = await readdir(sessions).catch(() => []);
   const listed = new Set([...folders].map(sessionFolderName));
@@ -59,12 +60,13 @@ const real = (path) => realpath(path).catch(() => path);
 /**
  * The projects on this computer, one per checkout or folder, each with the folders Claude Code ran
  * in inside it: their local MCP servers and session memory belong to it. `cwd` is added when it is
- * in a project. The home folder, those above it and Claude Code's own folder are never one.
+ * in a project, and so is each folder in `restored`, the config's list of folders a restore wrote
+ * into. The home folder, those above it and Claude Code's own folder are never one.
  */
-export async function findProjects({ home, claudeDir, claudeJson, cwd }) {
+export async function findProjects({ home, claudeDir, claudeJson, cwd, restored = [] }) {
   const projects = new Map();
   const own = await real(claudeDir);
-  for (const folder of [...(await knownFolders(claudeDir, claudeJson)), cwd]) {
+  for (const folder of [...(await knownFolders(claudeDir, claudeJson, Array.isArray(restored) ? restored : [])), cwd]) {
     const project = await findProject(folder, home);
     const inside = project && relative(own, project.root);
     if (!project || inside === "" || (inside && !inside.startsWith("..") && !isAbsolute(inside))) continue;

package/src/plan.mjs

@@ -15,6 +15,9 @@ export const toSlug = (name) =>
 /** A project's slug as the site makes it: its name's, and for a folder with no git remote that followed by the device's. */
 export const projectSlug = (project, deviceSlug) => (project.remote ? toSlug(project.name) : `${toSlug(project.name)}-${deviceSlug}`);
 
+/** What makes checkouts one project on the site: their GitHub repository, else their name. */
+export const projectIdentity = (project) => project.repo ?? project.name.toLowerCase();
+
 /**
  * The folder on this computer of a task's project, from the projects the sync finds: one with a
  * GitHub repository by that repository, any other by its slug, which for a folder with no git remote
@@ -137,8 +140,8 @@ export function describePlan(plan) {
     if (task.project && !task.folder) {
       detail.push(
         task.action === "copy"
-          ? `This computer has no folder of ${task.project.name}: clone it, then run skillcellar restore from inside it; or dismiss it on the site.`
-          : `This computer has no folder of ${task.project.name}: skip it, or dismiss it on the site.`,
+          ? `No folder of ${task.project.name} that Claude Code knows on this computer. If you cloned it, run skillcellar restore inside the clone; or dismiss the task on the site.`
+          : `No folder of ${task.project.name} that Claude Code knows on this computer: skip it, or dismiss it on the site.`,
       );
     }
     else if (task.problem) detail.push(`Cannot be carried out: ${task.problem}`);
@@ -153,7 +156,7 @@ export function describePlan(plan) {
     else if (task.install) detail.push(`${task.install.method}: ${task.install.command}`);
     if (task.item?.page && !task.link) detail.push(`Page: ${task.item.page}`);
     lines.push(...detail.map((line) => `   ${line}`));
-    if (task.action === "copy" && task.copy && !(task.project && !task.folder)) lines.push(...copyLines(task.copy));
+    if (task.action === "copy" && task.copy) lines.push(...copyLines(task.copy));
   });
   lines.push("", "Ask Claude Code to carry them out with the skillcellar skill, or do them yourself, then run skillcellar sync.");
   return lines;

package/src/restore.mjs

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { lstat, mkdir, stat, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { ensureMirror, git, gitBuffer, parseBackupRepo, refusePublic } from "./backup.mjs";
 import { sessionFolderName } from "./places.mjs";
@@ -16,6 +16,9 @@ const BYTES_MAX = 256 * 1024 * 1024;
 // The install commands a copy may hand over, in the shapes the site's plan gives them.
 const NPX_SKILLS_RE = /^npx skills add https:\/\/github\.com\/[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}(?: --skill [A-Za-z0-9][A-Za-z0-9._@+-]{0,127})?$/;
 const PLUGIN_RE = /^\/plugin (?:marketplace add [A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}, then \/plugin install |marketplace add https:\/\/[A-Za-z0-9._~:/%+-]+, then \/plugin install |install )[A-Za-z0-9][A-Za-z0-9._@+-]{0,127}$/;
+// A skill's name as its SKILL.md gives it, which `npx skills add --skill` matches on; printed in a command, so only these characters.
+const SKILL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._:@+-]{0,127}$/;
+const ANTIVIRUS = "an antivirus may have removed it (on Windows, see Windows Security, Protection history)";
 
 /** A path that stays inside its base folder, or null. */
 function inside(base, ...segments) {
@@ -24,6 +27,8 @@ function inside(base, ...segments) {
   return from && !from.startsWith("..") && !isAbsolute(from) ? path : null;
 }
 
+const isFile = async (path) => (await stat(path).catch(() => null))?.isFile() === true;
+
 /**
  * The backup's files at one commit, by path: the mode and the blob of each entry. Read from the
  * mirror's objects, never a checkout, so a link in the repository is listed and never followed.
@@ -82,6 +87,43 @@ function placeFolder(found, task) {
   return `${found.folder}/${place.folder}`;
 }
 
+/**
+ * What the backup holds in one place, as the items a sync reports: each skill folder, agent and
+ * memory file (CLAUDE.md, AGENTS.md, rules and session memory). MCP servers are left out: their
+ * config is one file per place, read only for a server the site names.
+ */
+function backupItems(tree, place, project) {
+  const items = new Map();
+  for (const path of tree.keys()) {
+    if (!path.startsWith(`${place}/`)) continue;
+    const rest = path.slice(place.length + 1);
+    const [first, ...more] = rest.split("/");
+    let item = null;
+    if (first === "skills") item = more.length > 1 ? { kind: "skill", name: more[0] } : null;
+    else if (first === "agents") item = rest.endsWith(".md") ? { kind: "agent", name: more.join("/").slice(0, -3) } : null;
+    else if (first !== "mcp.json" && first !== "mcp.local.json") item = { kind: "memory", name: rest };
+    if (item && sentName(item.kind, item.name, project)) items.set(`${item.kind}/${item.name}`, item);
+  }
+  return [...items.values()];
+}
+
+/**
+ * Where a skill, agent or memory file goes on this computer: a skill's folder, or a file's path;
+ * null for a name that would leave its folder.
+ */
+function targetOf({ kind, name }, { root, claudeDir }) {
+  const own = (...segments) => join(root ?? claudeDir, ...(root ? [".claude"] : []), ...segments);
+  if (kind === "skill") return join(own("skills"), name);
+  if (kind === "agent") return inside(own("agents"), `${name}.md`);
+  const [first, ...rest] = name.split("/");
+  if (first === "rules") return inside(own("rules"), ...rest);
+  if (first === "memory" && root) return inside(join(claudeDir, "projects", sessionFolderName(root), "memory"), ...rest);
+  return join(root ?? claudeDir, name);
+}
+
+/** Whether an item is on this computer already: a skill as a folder with its SKILL.md, a file as anything at its path. */
+const presentAt = async (target, kind) => (kind === "skill" ? isFile(join(target, "SKILL.md")) : (await lstat(target).catch(() => null)) !== null);
+
 const sha256 = (content) => createHash("sha256").update(content).digest("hex");
 
 /** Writes one file into place; "exists" when one is there already and `force` is not set, "link" when the target is a link. */
@@ -94,6 +136,15 @@ async function placeFile(content, target, force) {
   return "copied";
 }
 
+/** Whether every file of the backup's copy of a skill is in its folder here, byte for byte. */
+async function sameFiles(target, files) {
+  for (const file of files) {
+    const there = await readFile(join(target, ...file.segments)).catch(() => null);
+    if (!there?.equals(file.content)) return false;
+  }
+  return true;
+}
+
 const ENVIRONMENTS = [
   ["package.json", "npm install"],
   ["requirements.txt", "pip install -r requirements.txt"],
@@ -105,7 +156,7 @@ const ENVIRONMENTS = [
 /** The environments a restored skill folder names, each with the command that rebuilds it. */
 async function environmentsOf(folder) {
   const hints = [];
-  for (const [file, command] of ENVIRONMENTS) if ((await stat(join(folder, file)).catch(() => null))?.isFile()) hints.push(`${file} (${command})`);
+  for (const [file, command] of ENVIRONMENTS) if (await isFile(join(folder, file))) hints.push(`${file} (${command})`);
   return hints;
 }
 
@@ -116,23 +167,50 @@ async function checkProjectFolder(root, sub) {
   if ((await lstat(path).catch(() => null))?.isSymbolicLink()) throw new Error(`${path} is a link, so a file could land outside the project.`);
 }
 
+/** The name a SKILL.md's frontmatter gives, when a command can print it as it is; null otherwise. */
+async function skillMdName(mirror, entry, budget) {
+  if (!regular(entry)) return null;
+  const text = (await blobOf(mirror, entry, budget)).toString("utf8");
+  const front = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1] ?? "";
+  const name = /^name:[ \t]*["']?([^"'\r\n]*?)["']?[ \t]*$/m.exec(front)?.[1];
+  return name && SKILL_NAME_RE.test(name) ? name : null;
+}
+
+/**
+ * The `npx skills add` command of a skill from a repository, under the name its SKILL.md gives in the
+ * backup: the skills CLI matches on that name, which can differ from the folder's (react:components
+ * installs as react-components). Globally it adds -g, without which the skills CLI installs into the
+ * folder it runs in, and -y.
+ */
+async function skillCommand(command, name, { mirror, tree, budget, place, scope }) {
+  const named = await skillMdName(mirror, tree.get(`${place}/skills/${name}/SKILL.md`), budget);
+  const renamed = named && / --skill \S+$/.test(command) ? command.replace(/ --skill \S+$/, () => ` --skill ${named}`) : command;
+  return scope === "global" ? `${renamed} -g -y` : renamed;
+}
+
 /**
  * One item of a copy, in one place: files from the backup are written into Claude Code's folders,
- * once they match what the source reported and hold nothing that looks like a secret, and what a
- * command installs, a plugin, a skill from a repository or an MCP server, is answered as that
- * command for Claude Code or the user to run. Nothing is run here.
+ * once they match what the source reported (or the user takes the backup's copy) and hold nothing
+ * that looks like a secret, and what a command installs, a plugin, a skill from a repository or an
+ * MCP server, is answered as that command for Claude Code or the user to run. Nothing is run here.
  */
-async function restoreItem(item, { mirror, tree, budget, place, scope, root, claudeDir, force, dryRun }) {
+async function restoreItem(item, { mirror, tree, budget, place, scope, root, claudeDir, force, dryRun, allowed, takeBackup, fromBackup }) {
+  // A file that looks like it holds a secret is copied only as the source's user allowed it, byte for byte.
+  const secretIn = (path, content) => {
+    const found = findSecret(content.toString("utf8"));
+    return found && allowed.get(path) !== sha256(content) ? found : null;
+  };
   const { kind, name } = item;
   if (item.tracked) return { outcome: "repository" };
-  if (kind === "plugin" || (kind === "skill" && item.install)) {
+  if (kind === "plugin" || (kind === "skill" && item.install && !fromBackup.has(name))) {
     const command = item.install?.command;
     if (typeof command !== "string") return { outcome: "missing" };
-    return (kind === "plugin" ? PLUGIN_RE : NPX_SKILLS_RE).test(command) ? { outcome: "command", command } : { outcome: "odd-command", command };
+    if (!(kind === "plugin" ? PLUGIN_RE : NPX_SKILLS_RE).test(command)) return { outcome: "odd-command", command };
+    if (kind === "plugin") return { outcome: "command", command, plugin: true };
+    return { outcome: "command", command: await skillCommand(command, name, { mirror, tree, budget, place, scope }), inBackup: tree.has(`${place}/skills/${name}/SKILL.md`) };
   }
   if (!["skill", "mcp", "memory", "agent"].includes(kind)) return { outcome: "unknown-kind" };
   if (!sentName(kind, name, scope === "project")) return { outcome: "unsendable" };
-  const own = (...segments) => join(root ?? claudeDir, ...(root ? [".claude"] : []), ...segments);
   if (kind === "mcp") {
     const local = await readJsonBlob(mirror, tree.get(`${place}/mcp.local.json`), budget);
     const shared = await readJsonBlob(mirror, tree.get(`${place}/mcp.json`), budget);
@@ -153,49 +231,47 @@ async function restoreItem(item, { mirror, tree, budget, place, scope, root, cla
       if (!path.startsWith(prefix)) continue;
       if (!regular(entry)) return { outcome: "link", path };
       const content = await blobOf(mirror, entry, budget);
-      const found = findSecret(content.toString("utf8"));
+      const found = secretIn(path, content);
       if (found) return { outcome: "secret", path, line: found.line, kind: found.kind };
       files.push({ segments: path.slice(prefix.length).split("/"), content, executable: entry.mode === "100755" });
     }
     if (!files.length) return { outcome: "missing" };
     if (root) await checkProjectFolder(root, "skills");
-    const skills = own("skills");
-    const target = join(skills, name);
-    if (dryRun) return { outcome: (await lstat(target).catch(() => null)) && !force ? "exists" : "copied", target };
+    const skills = join(root ?? claudeDir, ...(root ? [".claude"] : []), "skills");
+    const target = targetOf(item, { root, claudeDir });
+    if ((await lstat(target).catch(() => null)) && !force) {
+      // A folder without its SKILL.md is not a skill Claude Code loads, so it is not "there already".
+      if (!(await isFile(join(target, "SKILL.md")))) return { outcome: "incomplete", target };
+      return { outcome: "exists", target, same: await sameFiles(target, files) };
+    }
+    if (dryRun) return { outcome: "copied", target };
     try {
       await installPulled(skills, { slug: name, files }, force);
     } catch (error) {
-      if (/is there already/.test(error.message)) return { outcome: "exists", target };
+      if (/is there already/.test(error.message)) return { outcome: "exists", target, same: false };
       throw error;
     }
+    if (!(await isFile(join(target, "SKILL.md")))) return { outcome: "vanished", target };
     return { outcome: "copied", target, environments: await environmentsOf(target) };
   }
-  let path;
-  let target;
-  if (kind === "agent") {
-    path = `${place}/agents/${name}.md`;
-    if (root) await checkProjectFolder(root, "agents");
-    target = inside(own("agents"), `${name}.md`);
-  } else {
-    const [first, ...rest] = name.split("/");
-    path = `${place}/${name}`;
-    if (first === "rules") {
-      if (root) await checkProjectFolder(root, "rules");
-      target = inside(own("rules"), ...rest);
-    } else if (first === "memory" && root) target = inside(join(claudeDir, "projects", sessionFolderName(root), "memory"), ...rest);
-    else target = join(root ?? claudeDir, name);
-  }
+  if (kind === "agent" && root) await checkProjectFolder(root, "agents");
+  if (kind === "memory" && name.startsWith("rules/") && root) await checkProjectFolder(root, "rules");
+  const path = kind === "agent" ? `${place}/agents/${name}.md` : `${place}/${name}`;
+  const target = targetOf(item, { root, claudeDir });
   const entry = tree.get(path);
   if (!entry) return { outcome: "missing" };
   if (!regular(entry)) return { outcome: "link", path };
   if (!target) return { outcome: "unsendable" };
   const content = await blobOf(mirror, entry, budget);
-  // The site holds the file's hash as the source reported it: a file that differs is not the source's.
-  if (item.hash && sha256(content) !== item.hash) return { outcome: "differs" };
-  const found = findSecret(content.toString("utf8"));
+  // The site holds the file's hash as the source reported it: a copy that differs is taken only on the user's word.
+  const differs = Boolean(item.hash) && sha256(content) !== item.hash;
+  if (differs && !takeBackup) return { outcome: "differs" };
+  const found = secretIn(path, content);
   if (found) return { outcome: "secret", path, line: found.line, kind: found.kind };
-  if (dryRun) return { outcome: (await lstat(target).catch(() => null)) && !force ? "exists" : "copied", target };
-  return { outcome: await placeFile(content, target, force), target };
+  const there = await lstat(target).catch(() => null);
+  if (there && !force && !there.isSymbolicLink()) return { outcome: "exists", target, same: (await readFile(target).catch(() => null))?.equals(content) === true };
+  if (dryRun) return { outcome: there?.isSymbolicLink() ? "link" : "copied", target, differs };
+  return { outcome: await placeFile(content, target, force), target, differs };
 }
 
 const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
@@ -216,9 +292,13 @@ async function trustedRepo(repo, source, config, flags) {
 function describe(result, label, source, dryRun) {
   switch (result.outcome) {
     case "copied":
-      return `${dryRun ? "would copy" : "copied"} ${label} to ${result.target}`;
+      return `${dryRun ? "would copy" : "copied"} ${label} to ${result.target}${result.differs ? ` (the backup's copy, which is not the one ${source.device.name} last reported)` : ""}`;
     case "exists":
-      return `kept ${label}: ${result.target} is there already (run again with --force to replace it)`;
+      return `kept ${label}: ${result.target} is there already and differs from the backup's copy (run again with --force to replace it)`;
+    case "incomplete":
+      return `${label}: ${result.target} has no SKILL.md, so Claude Code does not load it: ${ANTIVIRUS}. Run again with --force to copy it again`;
+    case "vanished":
+      return `copied ${label} to ${result.target}, but its SKILL.md is gone already: ${ANTIVIRUS}`;
     case "odd-command":
       return `${label}: its install command is not one this tool hands over (${result.command.slice(0, 80)}); install it from the site's page`;
     case "repository":
@@ -234,7 +314,7 @@ function describe(result, label, source, dryRun) {
     case "secret":
       return `${label}: ${result.path}:${result.line} in the backup looks like ${result.kind}; not restored`;
     case "differs":
-      return `${label}: the backup's copy differs from what ${source.device.name} reported; run skillcellar backup there again`;
+      return `${label}: the backup's copy is not the one ${source.device.name} last reported (it changed after that sync, or in the backup since). If the backup is yours as you left it, run again with --take-backup to copy it`;
     default:
       return `${label}: not in the backup`;
   }
@@ -244,18 +324,21 @@ function describe(result, label, source, dryRun) {
  * Carries out the copy tasks of the plan whose source has a backup: refuses a public repository and
  * one this computer was not told to trust, fetches the backup into a bare mirror with the user's own
  * git, reads the commit the site recorded, writes skills, memory files and agents into place, and
- * lists the commands left to run.
+ * lists the commands left to run. Answers the project folders it restored, whatever was missing there, so a sync reads them and closes their tasks.
  */
 export async function runRestore({ plan, claudeDir, config, flags, version, print, warn }) {
   const force = flags.force === true;
   const dryRun = flags["dry-run"] === true;
+  const takeBackup = flags["take-backup"] === true;
+  const fromBackup = new Set(Array.isArray(flags["from-backup"]) ? flags["from-backup"] : []);
   const from = typeof flags.from === "string" ? flags.from.trim().toLowerCase() : null;
+  const folders = new Set();
   const wanted = (plan.tasks ?? []).filter(
     (task) => task.action === "copy" && task.copy && (!from || task.copy.from.device.slug === from || task.copy.from.device.name.toLowerCase() === from),
   );
   if (!wanted.length) {
     print(from ? `No copy task from ${flags.from} waits for ${plan.device.name}.` : `No copy task waits for ${plan.device.name}.`);
-    return;
+    return { folders };
   }
   const bySource = new Map();
   for (const task of wanted) bySource.set(task.copy.from.device.id, [...(bySource.get(task.copy.from.device.id) ?? []), task]);
@@ -295,7 +378,16 @@ export async function runRestore({ plan, claudeDir, config, flags, version, prin
       warn(`${repo.name} at ${commit.slice(0, 7)} holds no backup of ${source.device.name}. Run skillcellar backup there, then restore here again.`);
       continue;
     }
+    const listed = Array.isArray(found.manifest?.allowed) ? found.manifest.allowed : [];
+    const allowed = new Map(listed.filter((entry) => typeof entry?.path === "string" && typeof entry.sha256 === "string").map((entry) => [`${found.folder}/${entry.path}`, entry.sha256]));
     print(`${dryRun ? "Would restore" : "Restoring"} from ${source.device.name}'s backup, ${repo.name} at ${commit.slice(0, 7)}:`);
+    // What any task names in a place, so the backup's other items there are told apart from them.
+    const reported = new Set(
+      tasks.flatMap((task) => {
+        const place = placeFolder(found, task);
+        return place ? task.copy.items.map((item) => `${place}/${item.kind}/${item.name}`) : [];
+      }),
+    );
     for (const task of tasks) {
       const where = task.project ? `in ${task.project.name}` : "globally";
       if (task.problem) {
@@ -303,7 +395,7 @@ export async function runRestore({ plan, claudeDir, config, flags, version, prin
         continue;
       }
       if (task.project && !task.folder) {
-        print(`  ${where}: this computer has no folder of ${task.project.name}; clone it, then run skillcellar restore from inside it.`);
+        print(`  ${where}: no folder of ${task.project.name} that Claude Code knows on this computer. If you cloned it, run skillcellar restore inside the clone.`);
         continue;
       }
       const place = placeFolder(found, task);
@@ -311,26 +403,50 @@ export async function runRestore({ plan, claudeDir, config, flags, version, prin
         print(`  ${where}: the backup holds nothing for this place.`);
         continue;
       }
-      if (!task.copy.items.length) print(`  ${where}: nothing left to copy; the next sync closes the task.`);
-      for (const item of task.copy.items) {
+      if (task.folder && !dryRun) folders.add(task.folder);
+      const context = { mirror, tree, budget, place, scope: task.scope, root: task.folder, claudeDir, force, dryRun, allowed, takeBackup, fromBackup };
+      let inPlace = 0;
+      const bring = async (item, note = "") => {
         const label = `${item.kind} ${item.name}`;
         const key = `${place}/${label}`;
         if (done.has(key)) {
           print(`  ${label}: brought over above`);
-          continue;
+          return;
         }
         done.add(key);
-        const result = await restoreItem(item, { mirror, tree, budget, place, scope: task.scope, root: task.folder, claudeDir, force, dryRun });
+        const result = await restoreItem(item, context);
         if (result.outcome === "command") {
           commands.push({ task: where, label, ...result });
-          continue;
+          return;
+        }
+        if (result.outcome === "exists" && result.same) {
+          inPlace += 1;
+          return;
         }
         if (result.outcome === "copied") {
           copied += 1;
           for (const hint of result.environments ?? []) environments.push(`${item.name} has ${hint}`);
         }
-        print(`  ${describe(result, label, source, dryRun)}`);
+        print(`  ${describe(result, label, source, dryRun)}${note}`);
+      };
+      if (!task.copy.items.length) print(`  ${where}: nothing left to copy; the next sync closes the task.`);
+      for (const item of task.copy.items) await bring(item);
+      // A copy of everything also finds what the backup holds that the source's last sync did not report.
+      if (!task.item) {
+        const unlisted = [];
+        for (const item of backupItems(tree, place, task.scope === "project")) {
+          if (reported.has(`${place}/${item.kind}/${item.name}`)) continue;
+          const target = targetOf(item, { root: task.folder, claudeDir });
+          if (target && !(await presentAt(target, item.kind))) unlisted.push(item);
+        }
+        if (unlisted.length && !takeBackup) {
+          print(
+            `  ${where}: ${plural(unlisted.length, "item")} in the backup that ${source.device.name}'s last sync did not report (added after that sync, or removed before it): ${unlisted.map((item) => `${item.kind} ${item.name}`).join(", ")}. Run again with --take-backup to copy ${unlisted.length === 1 ? "it" : "them"}.`,
+          );
+        }
+        if (takeBackup) for (const item of unlisted) await bring(item, ` (in the backup, not in ${source.device.name}'s last sync)`);
       }
+      if (inPlace) print(`  ${where}: ${plural(inPlace, "item")} already in place, the same as in the backup.`);
     }
   }
   if (commands.length) {
@@ -339,7 +455,14 @@ export async function runRestore({ plan, claudeDir, config, flags, version, prin
       const notes = [...(entry.placeholders?.length ? [`needs ${entry.placeholders.join(", ")}`] : []), ...(entry.review?.length ? [`review: ${entry.review.join(", ")}`] : [])];
       print(`  ${entry.task}: ${entry.command}${notes.length ? `   (${notes.join("; ")})` : ""}`);
     }
+    if (commands.some((entry) => entry.inBackup)) {
+      print("If npx skills add finds no matching skill, the skill has left its repository: run skillcellar restore --from-backup <name> to copy the backup's copy instead.");
+    }
+    if (commands.some((entry) => entry.plugin)) {
+      print("If /plugin install says the plugin is not in its marketplace, the marketplace was renamed after the old computer added it: install the plugin under the name /plugin marketplace list shows for it.");
+    }
   }
   if (environments.length) print(`Rebuild: ${environments.join("; ")}.`);
   if (!dryRun) print(`${copied ? `Copied ${plural(copied, "item")}. ` : ""}Run skillcellar sync to close the tasks that are done.`);
+  return { folders };
 }

package/src/scan.mjs

@@ -42,8 +42,9 @@ const byName = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
 
 /**
  * The skills in a skills directory as Claude Code loads them: each folder directly inside it, or a
- * link to one, with a SKILL.md of its own. Hidden folders, `learned`, `synced` and `*-workspace`
- * are skipped, and so is a folder whose skills sit deeper inside it.
+ * link to one, with a SKILL.md of its own. Hidden folders, `learned` and `synced` are skipped, and
+ * so is a folder whose skills sit deeper inside it, such as skill-creator's `*-workspace` folders;
+ * a folder with a SKILL.md of its own is a skill whatever its name.
  */
 export async function skillFolders(dir) {
   let entries;
@@ -56,7 +57,7 @@ export async function skillFolders(dir) {
   const folders = [];
   for (const entry of entries) {
     const { name } = entry;
-    if (name.startsWith(".") || SKIPPED_FOLDERS.has(name) || name.endsWith("-workspace")) continue;
+    if (name.startsWith(".") || SKIPPED_FOLDERS.has(name)) continue;
     const path = join(dir, name);
     const [folder, skillMd] = await Promise.all([stat(path).catch(() => null), stat(join(path, "SKILL.md")).catch(() => null)]);
     if (folder?.isDirectory() && skillMd?.isFile()) folders.push({ name, path });

package/src/secrets.mjs

@@ -9,6 +9,16 @@ const EDGE = String.raw`(?<![A-Za-z0-9])`;
 const END = String.raw`(?![A-Za-z0-9])`;
 // A value that is not a placeholder, a variable, a template, an example or a reference into config or code.
 const NOT_PLACEHOLDER = String.raw`(?!\$\{|\$[A-Za-z_]|<|\{\{|%|your[_-]|xxx|example|placeholder|change[_-]?me|redacted|none\b|null\b|true\b|false\b|\*{3}|process\.|os\.|env\.|config\.|settings\.|this\.|self\.)`;
+// The characters an assigned or bearer value is read with.
+const VALUE = String.raw`[A-Za-z0-9_\-./+=]`;
+// A word in either case, for a pattern that minds case.
+const anyCase = (word) => word.replace(/[a-z]/g, (letter) => `[${letter}${letter.toUpperCase()}]`);
+const EXAMPLE_WORDS = ["dummy", "fake", "sample", "example", "placeholder", "redacted", "change[_-]?me"].map(anyCase).join("|");
+// A value as documentation writes one, not a key: elided (abc123... or abc123…), or holding a word,
+// not part of a longer one, that calls it an example. Real keys are neither.
+const NOT_EXAMPLE = String.raw`(?!${VALUE}{0,255}?(?:\.\.\.|(?<![A-Za-z])(?:${EXAMPLE_WORDS})(?![A-Za-z])))(?!${VALUE}{1,255}…)`;
+// Code such as base64.b64encode( is no value; a quoted value is one, whatever it holds.
+const NOT_CALL = String.raw`(?:(?<=["'\x60])|(?![A-Za-z_]\w{0,60}(?:\.[A-Za-z_]\w{0,60}){1,5}\())`;
 
 const PATTERNS = [
   ["a private key", /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY(?: BLOCK)?-----/],
@@ -25,12 +35,12 @@ const PATTERNS = [
   ["a JSON Web Token", new RegExp(String.raw`${EDGE}eyJ[A-Za-z0-9_-]{10,2000}\.[A-Za-z0-9_-]{10,2000}\.[A-Za-z0-9_-]{10,2000}(?![A-Za-z0-9_-])`)],
   // user:password@host in an address of any scheme, unless the password is a placeholder.
   ["a password in an address", /[a-z][a-z0-9+.-]{0,30}:\/\/[^\s/@:'"]{1,100}:(?!\$\{)[^\s/@'"]{1,200}@/i],
-  ["a bearer or basic credential", new RegExp(String.raw`\b(?:Bearer|Basic)\s{1,5}(?!\$\{|\$[A-Za-z_]|<)[A-Za-z0-9_\-./+=]{16,2000}(?![A-Za-z0-9_\-./+=])`)],
+  ["a bearer or basic credential", new RegExp(String.raw`\b(?:Bearer|Basic)\s{1,5}(?!\$\{|\$[A-Za-z_]|<)${NOT_EXAMPLE}[A-Za-z0-9_\-./+=]{16,2000}(?![A-Za-z0-9_\-./+=])`)],
   // A key named as one, assigned a value with a digit in it, as random keys have; the name may be quoted, as in JSON.
   [
     "a key or password in an assignment",
     new RegExp(
-      String.raw`${EDGE}(?:api[_-]?key|apikey|secret[_-]?(?:access[_-]?)?key|access[_-]?token|auth[_-]?token|refresh[_-]?token|client[_-]?secret|private[_-]?key|password|passwd|secret|token)${END}["'\x60]?\s{0,5}[:=]\s{0,5}["'\x60]?${NOT_PLACEHOLDER}(?=[A-Za-z0-9_\-./+=]{0,254}[0-9])[A-Za-z0-9_\-./+=]{8,255}`,
+      String.raw`${EDGE}(?:api[_-]?key|apikey|secret[_-]?(?:access[_-]?)?key|access[_-]?token|auth[_-]?token|refresh[_-]?token|client[_-]?secret|private[_-]?key|password|passwd|secret|token)${END}["'\x60]?\s{0,5}[:=]\s{0,5}["'\x60]?${NOT_PLACEHOLDER}${NOT_EXAMPLE}${NOT_CALL}(?=[A-Za-z0-9_\-./+=]{0,254}[0-9])[A-Za-z0-9_\-./+=]{8,255}`,
       "i",
     ),
   ],