@indigoai-us/hq-cloud 6.14.9 → 6.14.11

package/src/cli/sync.ts

@@ -49,6 +49,7 @@ import {
   migratePersonalVaultJournal,
 } from "../journal.js";
 import { PERSONAL_VAULT_MANIFEST_KEY } from "../personal-vault.js";
+import { isPersonalVaultExcluded } from "../personal-vault-exclusions.js";
 import {
   buildScopeShrinkPlan,
   applyScopeShrink,
@@ -221,7 +222,13 @@ export type SyncProgressEvent =
       path: string;
       journalEtag: string;
       remoteEtag: string;
-      reason: "stale-etag" | "legacy-no-etag" | "bulk-asymmetry" | "divergent-local";
+      reason:
+        | "stale-etag"
+        | "legacy-no-etag"
+        | "bulk-asymmetry"
+        | "divergent-local"
+        | "missing-delete-intent"
+        | "intent-changed";
     }
   | {
       /**
@@ -1202,11 +1209,19 @@ function executeFileTombstoneDelete(
   counters: PullCounters,
 ): void {
   const tombstoneKey = item.remoteFile.key;
-  const tombstonePath = resolveContainedVaultPath(run.companyRoot, tombstoneKey);
-  if (tombstonePath === null) return;
+  const tombstonePath = item.localPath;
+  if (!isDownloadWritePathStillContained(run.companyRoot, tombstoneKey, tombstonePath)) {
+    run.emit({
+      type: "error",
+      path: tombstoneKey,
+      message: "tombstone-suppress unlink skipped: local parent escaped the sync root",
+    });
+    return;
+  }
   try {
     const lstat = fs.lstatSync(tombstonePath);
-    if (tombstoneTargetDiverged(run.journal, tombstoneKey, tombstonePath, lstat)) {
+    if (!matchesLocalSnapshot(tombstonePath, item.localSnapshot)) {
+      reportLocalSnapshotConflict(run, counters, tombstoneKey);
       return;
     }
     if (lstat.isSymbolicLink() || lstat.isFile()) {
@@ -1252,7 +1267,13 @@ async function executeConflictItem(
   // the `.conflict-` mirror loop AND the journal false-stamp (remote etag over
   // divergent local content) that the keep path produced for these files.
   if (isCloudAuthoritative(vaultKeyForLocalPath(run.hqRoot, localPath))) {
-    downloadItems.push({ action: "download", remoteFile, localPath, isNew: false });
+    downloadItems.push({
+      action: "download",
+      remoteFile,
+      localPath,
+      isNew: false,
+      localSnapshot: item.localSnapshot,
+    });
     run.emit({ type: "reconciled", path: remoteFile.key, direction: "pull" });
     return null;
   }
@@ -1315,6 +1336,7 @@ async function executeConflictItem(
       "down",
       remoteFile.etag,
       item.localMtime.getTime(),
+      item.localSnapshot.kind === "symlink" ? "symlink" : "file",
     );
     run.emit({ type: "reconciled", path: remoteFile.key, direction: "pull" });
     counters.filesSkipped++;
@@ -1404,6 +1426,7 @@ async function executeConflictItem(
       "down",
       remoteFile.etag,
       item.localMtime.getTime(),
+      item.localSnapshot.kind === "symlink" ? "symlink" : "file",
     );
     // Journal-honesty: we recorded the remote etag so this conflict can't
     // re-fire (#137), but the KEPT local copy diverges from that remote — it
@@ -1421,6 +1444,7 @@ async function executeConflictItem(
     remoteFile,
     localPath,
     isNew: false,
+    localSnapshot: item.localSnapshot,
   });
   return null;
 }
@@ -1494,6 +1518,13 @@ async function downloadOne(
       run.ctx,
       remoteFile.key,
       localPath,
+      {
+        beforeReplace: () => {
+          if (!matchesLocalSnapshot(localPath, downloadItem.localSnapshot)) {
+            throw new LocalSnapshotChangedError(remoteFile.key);
+          }
+        },
+      },
     );
     reportModeWarnings(run, modeWarnings);
     const author = metadata?.["created-by"] ?? null;
@@ -1515,6 +1546,7 @@ async function downloadOne(
       remoteFile.etag,
       localLstat.mtimeMs,
       createdBySub,
+      isLocalSymlink ? "symlink" : "file",
     );
 
     const priorEntry = getEntry(run.journal, remoteFile.key);
@@ -1531,7 +1563,9 @@ async function downloadOne(
     counters.bytesDownloaded += size;
     counters.changedPaths.push(remoteFile.key);
   } catch (err) {
-    if (isAccessDenied(err)) {
+    if (err instanceof LocalSnapshotChangedError) {
+      reportLocalSnapshotConflict(run, counters, remoteFile.key);
+    } else if (isAccessDenied(err)) {
       counters.filesSkipped++;
     } else {
       run.emit({
@@ -1622,13 +1656,13 @@ async function verifyPlannedJournalTombstones(
   // never legitimately exist in a company vault, so treating it as verified
   // is safe: the executor cleans the local copy + journal entry instead of
   // the push leg ever re-uploading it (tombstone-not-reupload).
-  const autoVerified: string[] = [];
-  const toHeadVerify: string[] = [];
-  for (const key of plan.tombstones) {
-    if (run.options.personalMode !== true && key.startsWith("companies/")) {
-      autoVerified.push(key);
+  const autoVerified: PullPlan["tombstones"] = [];
+  const toHeadVerify: PullPlan["tombstones"] = [];
+  for (const tombstone of plan.tombstones) {
+    if (run.options.personalMode !== true && tombstone.key.startsWith("companies/")) {
+      autoVerified.push(tombstone);
     } else {
-      toHeadVerify.push(key);
+      toHeadVerify.push(tombstone);
     }
   }
   plan.tombstones = toHeadVerify;
@@ -1637,22 +1671,22 @@ async function verifyPlannedJournalTombstones(
     return;
   }
 
-  await primeObjectTransport(run.ctx, "get", plan.tombstones);
+  await primeObjectTransport(run.ctx, "get", plan.tombstones.map((t) => t.key));
 
   const HEAD_VERIFY_CONCURRENCY = 5;
-  const verified: string[] = [];
+  const verified: PullPlan["tombstones"] = [];
   for (let i = 0; i < plan.tombstones.length; i += HEAD_VERIFY_CONCURRENCY) {
     const batch = plan.tombstones.slice(i, i + HEAD_VERIFY_CONCURRENCY);
     const results = await Promise.all(
-      batch.map(async (key) => {
+      batch.map(async (tombstone) => {
         try {
-          const head = await headRemoteFile(run.ctx, key);
-          return head === null ? key : null;
+          const head = await headRemoteFile(run.ctx, tombstone.key);
+          return head === null ? tombstone : null;
         } catch (err) {
           if (isAccessDenied(err)) return null;
           run.emit({
             type: "error",
-            path: key,
+            path: tombstone.key,
             message: `tombstone HEAD verify failed (deferring): ${
               err instanceof Error ? err.message : String(err)
             }`,
@@ -1661,8 +1695,8 @@ async function verifyPlannedJournalTombstones(
         }
       }),
     );
-    for (const k of results) {
-      if (k !== null) verified.push(k);
+    for (const tombstone of results) {
+      if (tombstone !== null) verified.push(tombstone);
     }
   }
   plan.tombstones = [...autoVerified, ...verified];
@@ -1673,13 +1707,21 @@ function executeJournalTombstoneDeletes(
   plan: PullPlan,
   counters: PullCounters,
 ): void {
-  for (const key of plan.tombstones) {
-    const localPath = resolveContainedVaultPath(run.companyRoot, key);
-    if (localPath === null) continue;
+  for (const tombstone of plan.tombstones) {
+    const { key, localPath, localSnapshot } = tombstone;
+    if (!isDownloadWritePathStillContained(run.companyRoot, key, localPath)) {
+      run.emit({
+        type: "error",
+        path: key,
+        message: "tombstone unlink skipped: local parent escaped the sync root",
+      });
+      continue;
+    }
     let removedSomething = false;
     try {
       const lstat = fs.lstatSync(localPath);
-      if (tombstoneTargetDiverged(run.journal, key, localPath, lstat)) {
+      if (!matchesLocalSnapshot(localPath, localSnapshot)) {
+        reportLocalSnapshotConflict(run, counters, key);
         continue;
       }
       if (lstat.isSymbolicLink() || lstat.isFile()) {
@@ -1880,29 +1922,64 @@ function isDownloadWritePathStillContained(
   return resolved !== null && path.resolve(resolved) === path.resolve(localPath);
 }
 
-function tombstoneTargetDiverged(
-  journal: SyncJournal,
-  key: string,
-  localPath: string,
-  lstat: fs.Stats,
-): boolean {
-  const journalEntry = journal.files[key];
-  if (!journalEntry?.hash) {
-    return lstat.isSymbolicLink() || lstat.isFile();
-  }
-
+function snapshotLocalState(localPath: string): LocalSnapshot | null {
   try {
+    const lstat = fs.lstatSync(localPath);
     if (lstat.isSymbolicLink()) {
-      return hashSymlinkTarget(fs.readlinkSync(localPath)) !== journalEntry.hash;
+      return { kind: "symlink", hash: hashSymlinkTarget(fs.readlinkSync(localPath)) };
     }
     if (lstat.isFile()) {
-      return hashFile(localPath) !== journalEntry.hash;
+      return { kind: "file", hash: hashFile(localPath) };
     }
-  } catch {
-    return true;
+    if (lstat.isDirectory()) return { kind: "directory" };
+    return { kind: "other" };
+  } catch (err: unknown) {
+    const code =
+      err && typeof err === "object" && "code" in err
+        ? (err as { code?: string }).code
+        : undefined;
+    return code === "ENOENT" ? { kind: "absent" } : null;
   }
+}
+
+function matchesLocalSnapshot(localPath: string, expected: LocalSnapshot): boolean {
+  const actual = snapshotLocalState(localPath);
+  if (actual === null || actual.kind !== expected.kind) return false;
+  return (
+    (actual.kind !== "file" && actual.kind !== "symlink") ||
+    actual.hash === (expected as Extract<LocalSnapshot, { hash: string }>).hash
+  );
+}
+
+function hasCurrentLocalDeleteIntent(
+  entry: SyncJournal["files"][string] | undefined,
+): boolean {
+  const intent = entry?.localDeleteIntent;
+  return !!(
+    intent &&
+    intent.version === 1 &&
+    entry.remoteEtag &&
+    entry.kind &&
+    intent.remoteEtag === entry.remoteEtag &&
+    intent.localHash === entry.hash &&
+    intent.localKind === entry.kind
+  );
+}
 
-  return false;
+function reportLocalSnapshotConflict(
+  run: PullRunContext,
+  counters: PullCounters,
+  key: string,
+): void {
+  counters.conflicts++;
+  counters.conflictPaths.push(key);
+  run.emit({ type: "conflict", path: key, direction: "pull", resolution: "skip" });
+}
+
+class LocalSnapshotChangedError extends Error {
+  constructor(key: string) {
+    super(`local state changed while downloading ${key}; replanning required`);
+  }
 }
 
 /**
@@ -1911,8 +1988,18 @@ function tombstoneTargetDiverged(
  * decide what to do. `localHash` is carried on `conflict` items so the
  * executor can hand it to `resolveConflict` without re-hashing.
  */
+type LocalSnapshot =
+  | { kind: "absent" | "directory" | "other" }
+  | { kind: "file" | "symlink"; hash: string };
+
 type PullPlanItem =
-  | { action: "download"; remoteFile: RemoteFile; localPath: string; isNew: boolean }
+  | {
+      action: "download";
+      remoteFile: RemoteFile;
+      localPath: string;
+      isNew: boolean;
+      localSnapshot: LocalSnapshot;
+    }
   | { action: "skip-ignored"; remoteFile: RemoteFile; localPath: string }
   | { action: "skip-personal-mode"; remoteFile: RemoteFile; localPath: string }
   | { action: "skip-unchanged"; remoteFile: RemoteFile; localPath: string }
@@ -1941,7 +2028,12 @@ type PullPlanItem =
   // (keys ABSENT from the LIST, HEAD-verified before delete), these are
   // suppressed purely on the FILE_TOMBSTONE authority and skip HEAD-verify (the
   // remote object is present by definition).
-  | { action: "tombstone-delete"; remoteFile: RemoteFile; localPath: string }
+  | {
+      action: "tombstone-delete";
+      remoteFile: RemoteFile;
+      localPath: string;
+      localSnapshot: LocalSnapshot;
+    }
   | {
       action: "conflict";
       remoteFile: RemoteFile;
@@ -1963,6 +2055,7 @@ type PullPlanItem =
       // and silently fail to stamp the journal — leaving the
       // conflict to re-fire forever.
       localSize: number;
+      localSnapshot: LocalSnapshot;
     };
 
 interface PullPlan {
@@ -1984,7 +2077,11 @@ interface PullPlan {
    * propagating the peer's push-side delete cross-machine (Bug #9).
    * Carried on the plan so the executor can iterate without re-walking.
    */
-  tombstones: string[];
+  tombstones: Array<{
+    key: string;
+    localPath: string;
+    localSnapshot: LocalSnapshot;
+  }>;
   /**
    * Count of `tombstone-delete` items — remote keys present in the LIST but
    * suppressed by a FILE_TOMBSTONE (delete-resync). Surfaced on the plan event's
@@ -2120,6 +2217,16 @@ function computePullPlan(
       continue;
     }
 
+    // Personal-vault policy must be symmetric across both transfer legs.
+    // The push walker refuses derived/machine-local/sensitive paths, but old
+    // objects can remain in the bucket from clients that predate an exclusion.
+    // Refuse those objects here too so a pull cannot rematerialize them (or,
+    // for generated skill wrappers, fight reindex over a directory link).
+    if (personalMode && isPersonalVaultExcluded(remoteFile.key)) {
+      items.push({ action: "skip-excluded-policy", remoteFile, localPath });
+      continue;
+    }
+
     if (
       personalMode &&
       remoteFile.key.startsWith("companies/") &&
@@ -2221,6 +2328,7 @@ function computePullPlan(
     const localTombstoneSuppresses =
       journalEntry !== undefined &&
       isTombstone(journalEntry) &&
+      hasCurrentLocalDeleteIntent(journalEntry) &&
       journalEntry.removedAt !== undefined &&
       !isRemoteRecreateAfterTombstone(remoteFile, {
         deletedAt: journalEntry.removedAt,
@@ -2239,6 +2347,7 @@ function computePullPlan(
     //      dangling link on every run.
     //   3. A regular file: indistinguishable from current behaviour.
     let localLstat: fs.Stats | null = null;
+    let plannedLocalSnapshot: LocalSnapshot = { kind: "absent" };
     let localPathBlockedByFileAncestor = false;
     try {
       localLstat = fs.lstatSync(localPath);
@@ -2345,6 +2454,10 @@ function computePullPlan(
           : hashFile(localPath);
       }
       const localChanged = !!journalEntry && journalEntry.hash !== localHash;
+      plannedLocalSnapshot = {
+        kind: isLocalSymlink ? "symlink" : "file",
+        hash: localHash,
+      };
       const remoteChanged =
         !!journalEntry && hasRemoteChanged(remoteFile, journalEntry);
 
@@ -2367,9 +2480,15 @@ function computePullPlan(
             localHash,
             localMtime: localLstat!.mtime,
             localSize: isLocalSymlink ? 0 : localLstat!.size,
+            localSnapshot: plannedLocalSnapshot,
           });
         } else {
-          items.push({ action: "tombstone-delete", remoteFile, localPath });
+          items.push({
+            action: "tombstone-delete",
+            remoteFile,
+            localPath,
+            localSnapshot: plannedLocalSnapshot,
+          });
         }
         continue;
       }
@@ -2395,6 +2514,7 @@ function computePullPlan(
           // every sync.
           localMtime: localLstat!.mtime,
           localSize: isLocalSymlink ? 0 : localLstat!.size,
+          localSnapshot: plannedLocalSnapshot,
         });
         continue;
       }
@@ -2454,6 +2574,7 @@ function computePullPlan(
             localHash,
             localMtime: localLstat!.mtime,
             localSize: localLstat!.size,
+            localSnapshot: plannedLocalSnapshot,
           });
           continue;
         }
@@ -2483,7 +2604,12 @@ function computePullPlan(
       if (journalEntry?.removedReason === "local-delete") {
         continue;
       }
-      items.push({ action: "tombstone-delete", remoteFile, localPath });
+      items.push({
+        action: "tombstone-delete",
+        remoteFile,
+        localPath,
+        localSnapshot: plannedLocalSnapshot,
+      });
       continue;
     }
 
@@ -2496,15 +2622,20 @@ function computePullPlan(
       !localExists &&
       journalEntry !== undefined &&
       !isTombstone(journalEntry) &&
-      !journalEntry.localDiverges &&
-      journalEntry.remoteEtag !== undefined &&
+      hasCurrentLocalDeleteIntent(journalEntry) &&
       normalizeEtag(remoteFile.etag) === journalEntry.remoteEtag
     ) {
       intentionalDeleteCandidates.push({ remoteFile, localPath });
       continue;
     }
 
-    items.push({ action: "download", remoteFile, localPath, isNew: !localExists });
+    items.push({
+      action: "download",
+      remoteFile,
+      localPath,
+      isNew: !localExists,
+      localSnapshot: plannedLocalSnapshot,
+    });
   }
 
   // ── Intentional-delete bulk-asymmetry decision (pull-leg producer) ─────────
@@ -2526,6 +2657,7 @@ function computePullPlan(
         remoteFile: cand.remoteFile,
         localPath: cand.localPath,
         isNew: true,
+        localSnapshot: { kind: "absent" },
       });
     } else {
       tombstoneEntry(journal, cand.remoteFile.key, "local-delete");
@@ -2585,7 +2717,7 @@ function computePullPlan(
   // `propagateDeletes` plan in share.ts.
   const remoteKeySet = new Set<string>();
   for (const rf of remoteFiles) remoteKeySet.add(rf.key);
-  const tombstones: string[] = [];
+  const tombstones: PullPlan["tombstones"] = [];
   for (const key of Object.keys(journal.files)) {
     // Compare membership in POSIX space. A pre-5.47.2 Windows journal key can
     // carry backslash separators; the remote LIST is always forward-slash, so a
@@ -2665,7 +2797,9 @@ function computePullPlan(
       // we can't read local state, so we can't safely decide.
       if (code !== "ENOENT") continue;
     }
-    tombstones.push(key);
+    const localSnapshot = snapshotLocalState(localPath);
+    if (localSnapshot === null) continue;
+    tombstones.push({ key, localPath, localSnapshot });
   }
 
   return {

package/src/journal.ts

@@ -425,6 +425,7 @@ export function updateEntry(
   remoteEtag?: string,
   mtimeMs?: number,
   createdBySub?: string,
+  kind?: "file" | "symlink",
 ): void {
   const entry: JournalEntry = {
     hash,
@@ -444,6 +445,9 @@ export function updateEntry(
   if (createdBySub !== undefined && createdBySub !== "") {
     entry.createdBySub = createdBySub;
   }
+  if (kind !== undefined) {
+    entry.kind = kind;
+  }
   journal.files[relativePath] = entry;
   journal.lastSync = new Date().toISOString();
 }
@@ -593,6 +597,30 @@ export function tombstoneEntry(
   entry.removedReason = reason;
 }
 
+/**
+ * Mark a journal entry for a user-authorized local delete. Callers must
+ * capture the local hash and kind before removing the object; an absent path
+ * alone is never deletion intent.
+ */
+export function markLocalDeleteIntent(
+  journal: SyncJournal,
+  relativePath: string,
+  localHash: string,
+  localKind: "file" | "symlink",
+): boolean {
+  const entry = journal.files[relativePath];
+  if (!entry?.remoteEtag || entry.hash !== localHash || entry.kind !== localKind) {
+    return false;
+  }
+  entry.localDeleteIntent = {
+    version: 1,
+    remoteEtag: entry.remoteEtag,
+    localHash,
+    localKind,
+  };
+  return true;
+}
+
 /** True if the entry is a tombstone (set by `tombstoneEntry`). */
 export function isTombstone(entry: JournalEntry | undefined): boolean {
   return !!entry && typeof entry.removedAt === "string";

package/src/personal-vault-exclusions.test.ts

@@ -183,6 +183,29 @@ describe("OS / build cruft exclusions", () => {
   });
 });
 
+describe("generated namespaced skill-wrapper exclusion", () => {
+  it.each([
+    ".claude/skills/indigo:call-prep-brief/scripts",
+    ".claude/skills/indigo:team-agent-telemetry-report/agents",
+    ".claude/skills/indigo%3Astandup-brief/template",
+    ".claude/skills/core:review/SKILL.md",
+  ])("excludes the derived link-farm path %s", (p) => {
+    expect(matchPersonalVaultExclusion(p)?.id).toBe("generated-skill-wrapper");
+  });
+
+  it.each([
+    ".claude/skills/deep-plan/SKILL.md",
+    "personal/skills/indigo:custom/SKILL.md",
+    ".claude/skills/indigo-call-prep/scripts",
+    ".claude/skills/:missing-namespace/SKILL.md",
+    ".claude/skills/missing-skill:/SKILL.md",
+  ])("does not exclude non-wrapper content %s", (p) => {
+    expect(matchPersonalVaultExclusion(p)?.id).not.toBe(
+      "generated-skill-wrapper",
+    );
+  });
+});
+
 // ── _testing internals ───────────────────────────────────────────────────────
 
 describe("_testing internals", () => {

package/src/personal-vault-exclusions.ts

@@ -29,7 +29,13 @@
  *      handled by `EPHEMERAL_PATH_PATTERN` in share.ts). Same logic
  *      applies: these are local-only safety backups.
  *
- *   5. OS / build cruft. `.DS_Store`, `node_modules/`, `dist/`, `.next/`,
+ *   5. Reindex-generated skill wrappers. `.claude/skills/<ns>:<skill>/`
+ *      (encoded as `<ns>%3A<skill>` on Windows) is a derived link farm over
+ *      canonical `core/`, `personal/`, package, or company skill sources.
+ *      Syncing the links duplicates their owners and makes personal pulls
+ *      fight reindex over directory links.
+ *
+ *   6. OS / build cruft. `.DS_Store`, `node_modules/`, `dist/`, `.next/`,
  *      `build/`. Universally noise inside HQ (personal scope should not
  *      contain code projects, but defense-in-depth catches anyone who
  *      symlinks a project subtree in).
@@ -43,14 +49,16 @@
  * Application scope: personal vault only. Company vaults have separate
  * first-push protection (settings/, data/, workers/, .git/ exclusion in
  * `src-tauri/src/util/ignore.rs`) and may legitimately ship `output/` or
- * `.env*` paths inside their data folders. Wired in `share.ts` only when
- * `options.personalMode === true`.
+ * `.env*` paths inside their data folders. Wired only when `personalMode`
+ * is true.
  *
  * Wire-points (parallel to `EPHEMERAL_PATH_PATTERN`):
  *   - `collectFiles` / `walkDir` (push) — wrap `shouldSync` so excluded
  *     relative paths are rejected before upload.
  *   - `computeDeletePlan` (delete) — same `shouldSync` wrap, so journal
  *     entries matching an exclusion are skipped on the delete pass too.
+ *   - `computePullPlan` (pull) — reject legacy remote objects before any
+ *     local inspection or download so excluded state cannot rematerialize.
  */
 
 import * as path from "path";
@@ -79,6 +87,7 @@ export interface PersonalVaultExclusion {
     | "machine-local"
     | "scratch"
     | "conflict-mirror"
+    | "generated-mirror"
     | "os-cruft"
     | "build-output";
   /**
@@ -104,6 +113,25 @@ function basename(relPath: string): string {
   return i === -1 ? relPath : relPath.slice(i + 1);
 }
 
+/**
+ * Reindex owns every namespaced wrapper under `.claude/skills/`. The wrapper
+ * segment is `<namespace>:<skill>` on POSIX and `<namespace>%3A<skill>` after
+ * the Win32 local-path codec escapes the reserved colon. Require non-empty
+ * names on both sides so hand-authored malformed paths are not swept up.
+ */
+function isGeneratedSkillWrapperPath(relPath: string): boolean {
+  const parts = relPath.split("/");
+  if (parts[0] !== ".claude" || parts[1] !== "skills" || parts.length < 3) {
+    return false;
+  }
+  const wrapper = parts[2] ?? "";
+  const literalColon = wrapper.indexOf(":");
+  if (literalColon > 0 && literalColon < wrapper.length - 1) return true;
+
+  const encodedColon = wrapper.toUpperCase().indexOf("%3A");
+  return encodedColon > 0 && encodedColon + 3 < wrapper.length;
+}
+
 export const PERSONAL_VAULT_DEFAULT_EXCLUSIONS: readonly PersonalVaultExclusion[] = [
   // ── secrets ───────────────────────────────────────────────────────────
   {
@@ -175,6 +203,13 @@ export const PERSONAL_VAULT_DEFAULT_EXCLUSIONS: readonly PersonalVaultExclusion[
     pattern: "**/.hq-conflicts/**",
     test: (p) => hasSegment(p, ".hq-conflicts"),
   },
+  // ── reindex-generated link farm ───────────────────────────────────────
+  {
+    id: "generated-skill-wrapper",
+    category: "generated-mirror",
+    pattern: ".claude/skills/<namespace>:<skill>/**",
+    test: (p) => isGeneratedSkillWrapperPath(p),
+  },
   // ── OS / build cruft ──────────────────────────────────────────────────
   {
     id: "ds-store",
@@ -285,4 +320,5 @@ export function wrapFilterWithPersonalVaultDefaults(
 export const _testing = {
   hasSegment,
   basename,
+  isGeneratedSkillWrapperPath,
 };

package/src/personal-vault.ts

@@ -105,6 +105,21 @@ export interface PersonalVaultOptions {
  */
 export const PERSONAL_VAULT_MANIFEST_KEY = "companies/manifest.yaml";
 
+/**
+ * Release-owned scaffold and reindex-generated wrappers must never be
+ * delete-propagated from the personal vault. They are recreated locally by a
+ * release or `hq reindex`, so an ordinary local absence is not user intent.
+ */
+export function isPersonalVaultDeletionExcluded(key: string): boolean {
+  const normalized = key.split("\\").join("/").replace(/^\.\//, "");
+  return (
+    normalized === "core" ||
+    normalized.startsWith("core/") ||
+    normalized === ".claude/skills" ||
+    normalized.startsWith(".claude/skills/")
+  );
+}
+
 export function computePersonalVaultPaths(
   hqRoot: string,
   opts: PersonalVaultOptions = {},