@@ -8,6 +8,6 @@ Clause-②: no
 
 - **The project depends on the catalog.** The blank template's `devDependencies` gain `@objectstack/skills`, at the same `^<version>` as every other `@objectstack/*` dependency, so a new project's dependency set changes: the skills are the ones written for the `@objectstack/spec` it installs.
 - **The install reads `node_modules`.** After `<pm> install`, the scaffolder runs `npx -y skills@1.7.2 experimental_sync --agent claude-code --copy -y`, which copies the installed package's catalog into `.claude/skills/` as real files, once, beside a `skills-lock.json` that names the package as every skill's source. The GitHub `npx skills add objectstack-ai/objectstack/skills …` command is gone from the run, its summary and the `AGENTS.md` and `README.md` it writes into the project.
-- **The summary says what happened.** It names the package version installed and prints the same command for re-installing after an upgrade of the `@objectstack/*` packages, and for any other agent runtime. When the install leaves no catalog to read, the run says so instead of reporting the skills installed.
+- **The summary says what happened.** It names the package version installed and prints the same command for re-installing after an upgrade of the `@objectstack/*` packages, and for any other agent runtime. When the install leaves no catalog to read, or a skill did not come from the package, the run says so instead of reporting the skills installed.
 - **The flags keep their meaning.** `--skip-skills` skips the skills step. `--skip-install` installs no skills, because nothing is in `node_modules` yet; the summary names `<pm> install` and then the sync command.
-- **To re-install skills in a project created earlier:** add `@objectstack/skills` to `devDependencies` at your `@objectstack/spec` range, run your package manager's install, then `npx skills@1.7.2 experimental_sync --agent claude-code --copy -y` (name your own runtime after `--agent`).
+- **To move a project created earlier onto the package:** add `@objectstack/skills` to `devDependencies` at your `@objectstack/spec` range and run your package manager's install. Remove the skills `skills add` installed — `npx skills remove objectstack-data -y` and so on for each `objectstack-*` skill, or `npx skills remove --all` if you installed no others — because the sync skips a skill it did not install and leaves the old copy in place. Then run `npx skills@1.7.2 experimental_sync --agent claude-code --copy -y` (name your own runtime after `--agent`).
@@ -86,6 +86,7 @@ import {
   listSkills,
   skillsInstallHint,
   skillsPackageDir,
+  skillsSyncedFromPackage,
 } from './skills-install.js';
 import { renderVersionBanner } from './banner.js';
 
@@ -390,10 +391,11 @@ function writeIfAbsent(filePath: string, contents: string) {
 // version installed, or `null` after a warning naming the remedy.
 //
 // The sync's exit code is not the verdict: with no package to read it prints
-// "Nothing to sync." and exits 0 (`skills-install.ts`). So both sides are read
-// here — a catalog in the package before the call, and every one of its skills
-// in the agent's directory after it — and a gap on either is said out loud
-// rather than summarised as "Installed".
+// "Nothing to sync." and exits 0, and it exits 0 having skipped a skill it did
+// not install (`skills-install.ts`). So both sides are read here — a catalog
+// in the package before the call, and every one of its skills in the agent's
+// directory, recorded in the lock as synced from the package, after it — and
+// a gap on either is said out loud rather than summarised as "Installed".
 function installSkillsFromPackage(
   targetDir: string,
   installed: boolean,
@@ -430,13 +432,17 @@ function installSkillsFromPackage(
     return null;
   }
 
+  // Both the files and the lock entry: the sync leaves an existing directory
+  // it did not write (one from `skills add`) in place and still exits 0.
   const landed = new Set(listSkills(path.join(targetDir, DEFAULT_SKILLS_DIR)));
-  const missing = catalog.filter((skill) => !landed.has(skill));
+  const synced = skillsSyncedFromPackage(targetDir);
+  const missing = catalog.filter((skill) => !landed.has(skill) || !synced.has(skill));
   if (missing.length > 0) {
     printWarning(
       `Skills installation incomplete: ${missing.length} of ${catalog.length} skill(s) in ` +
-        `${SKILLS_PACKAGE}@${version} did not land in ${DEFAULT_SKILLS_DIR} as files ` +
-        `(${missing.join(', ')}). Run manually:\n${hint}`,
+        `${SKILLS_PACKAGE}@${version} are not in ${DEFAULT_SKILLS_DIR} as files synced from it ` +
+        `(${missing.join(', ')}). The sync leaves a skill installed earlier with \`skills add\` ` +
+        `in place: remove it (\`npx skills remove <name> -y\`), then run:\n${hint}`,
     );
     console.log('');
     return null;
 
@@ -22,7 +22,9 @@
 //   -y           .agents/skills/<skill>  links into node_modules/<package>/…
 //                .claude/skills/<skill>  links into .agents/skills/<skill>
 //
-// and with nothing to read it prints "Nothing to sync." and exits 0.
+// With nothing to read it prints "Nothing to sync." and exits 0; a skill whose
+// directory is already there and whose lock entry is not a sync's (one from
+// `skills add`) is SKIPPED, left as it was, and the run still exits 0.
 //
 // ## Why both CLIs are stubbed, and how the stubs are kept honest
 //
@@ -164,21 +166,32 @@ for (const dep of deps) {
   }
 }
 if (found.length === 0) { console.log('Nothing to sync.'); process.exit(0); }
+const lockPath = path.join(cwd, 'skills-lock.json');
+let prior = { version: 1, skills: {} };
+try { prior = JSON.parse(fs.readFileSync(lockPath, 'utf8')); } catch {}
+const synced = found.filter((skill) => {
+  const taken = SHAPES[key].some((dest) => fs.existsSync(path.join(cwd, dest.dir, skill.name)));
+  if (taken && prior.skills?.[skill.name]?.sourceType !== 'node_modules') {
+    console.warn('Skipped ' + skill.name + ' from ' + skill.dep + ': installed with skills add');
+    return false;
+  }
+  return true;
+});
 for (const dest of SHAPES[key]) {
   fs.mkdirSync(path.join(cwd, dest.dir), { recursive: true });
-  for (const skill of found) {
+  for (const skill of synced) {
     const target = path.join(cwd, dest.dir, skill.name);
     if (dest.kind === 'copy') fs.cpSync(skill.src, target, { recursive: true });
     else if (dest.kind === 'link-package') fs.symlinkSync(path.relative(path.dirname(target), skill.src), target);
     else fs.symlinkSync(dest.into + '/' + skill.name, target);
   }
 }
-const lock = { version: 1, skills: {} };
-for (const s of found) {
+const lock = { version: 1, skills: { ...prior.skills } };
+for (const s of synced) {
   lock.skills[s.name] = { source: s.dep, sourceType: 'node_modules', skillPath: s.skillPath, version: s.version };
 }
 fs.writeFileSync(path.join(cwd, 'skills-lock.json'), JSON.stringify(lock, null, 2) + '\\n');
-console.log('npx-stub: synced ' + found.length + ' skills');
+console.log('npx-stub: synced ' + synced.length + ' skills');
 `;
 }
 
@@ -427,6 +440,33 @@ describe('without a package to read, no skills — and the run says how to get t
     expect(block).toContain(skillsInstallHint(DEFAULT_SKILLS_AGENT));
   });
 
+  // Scaffolding into the current directory is the one path onto existing
+  // content. A skill that `skills add` put there earlier is SKIPPED by the
+  // sync, exit 0, its directory still present — so neither the exit code nor
+  // the directory can be the verdict; the lock entry naming the package is.
+  it('a skill already there from `skills add` is reported, not counted as installed', () => {
+    const project = path.join(TMP, 'here-app');
+    const legacy = path.join(project, '.claude', 'skills', 'objectstack-data');
+    fs.mkdirSync(legacy, { recursive: true });
+    fs.writeFileSync(path.join(legacy, 'SKILL.md'), '---\nname: objectstack-data\n---\n\n# from main\n');
+    fs.writeFileSync(
+      path.join(project, 'skills-lock.json'),
+      JSON.stringify({ version: 1, skills: { 'objectstack-data': { source: 'objectstack-ai/objectstack', sourceType: 'github' } } }) + '\n',
+    );
+    const receipt = path.join(TMP, 'here-app.npx-argv.log');
+    const stdout = execFileSync(TSX, [INDEX_TS], {
+      cwd: project,
+      encoding: 'utf8',
+      env: { ...process.env, NPX_STUB_RECEIPT: receipt, PATH: `${BIN}${path.delimiter}${process.env.PATH ?? ''}` },
+    });
+    expect(fs.readFileSync(receipt, 'utf8').trim().split('\n')).toHaveLength(1);
+    expect(listSkills(path.join(project, DEFAULT_SKILLS_DIR))).toEqual(STUB_CATALOG);
+    expect(fs.readFileSync(path.join(legacy, 'SKILL.md'), 'utf8')).toContain('# from main');
+    expect(stdout).toContain('1 of 3 skill(s)');
+    expect(stdout).toContain('(objectstack-data)');
+    expect(stdout).not.toContain('Installed for');
+  });
+
   // The sync exits 0 with "Nothing to sync." when there is no package, so a
   // scaffolder that trusted the exit code would print "Installed".
   it('an install that leaves no catalog: the run says so, and never claims Installed', () => {
 
@@ -45,7 +45,12 @@
 // is the only one that ships any, so the synced set is exactly its catalog.
 // With no package to read it prints "Nothing to sync." and exits 0 — which is
 // why the scaffolder checks both sides itself (`listSkills` below) instead of
-// reading the exit code as "installed".
+// reading the exit code as "installed". It also exits 0 when it SKIPS a skill
+// whose directory is already there and was not put there by a sync — one from
+// `skills add`, say ("Skipped objectstack-data from @objectstack/skills:
+// installed with `skills add` …"), leaving that copy and its lock entry as
+// they were. So a directory being present proves nothing either; the lock
+// entry naming the package (`skillsSyncedFromPackage`) does.
 //
 // The CLI is pinned to the version measured. `experimental_` is that package's
 // own word for an interface it may change, and an unpinned `npx skills` would
@@ -143,6 +148,27 @@ export function installedSkillsVersion(projectDir: string): string | null {
   }
 }
 
+/** The skills CLI's record of what it installed, at the project root. */
+export const SKILLS_LOCK_FILE = 'skills-lock.json';
+
+/**
+ * The skills the project's `skills-lock.json` records as synced from the
+ * installed `@objectstack/skills` package (`source` the package,
+ * `sourceType: node_modules`). Empty when there is no readable lock.
+ */
+export function skillsSyncedFromPackage(projectDir: string): Set<string> {
+  try {
+    const lock = JSON.parse(fs.readFileSync(path.join(projectDir, SKILLS_LOCK_FILE), 'utf8'));
+    return new Set(
+      Object.entries((lock?.skills ?? {}) as Record<string, { source?: unknown; sourceType?: unknown }>)
+        .filter(([, entry]) => entry?.source === SKILLS_PACKAGE && entry?.sourceType === 'node_modules')
+        .map(([name]) => name),
+    );
+  } catch {
+    return new Set();
+  }
+}
+
 /**
  * The skills under `dir` — the names of its immediate subdirectories that
  * hold a `SKILL.md` — sorted. Empty when `dir` does not exist. A symlinked