@remnic/core 9.65.3 → 9.65.4

package/dist/{chunk-H5FW4S5Q.js → chunk-ZPOHEB5Z.js}

@@ -6,14 +6,14 @@ import {
   loadSyncState,
   syncWearableSource,
   wearableSourceLabel
-} from "./chunk-CDUUDBWJ.js";
+} from "./chunk-VFYRYFLL.js";
 import {
   CompressionGuidelineCoordinator
 } from "./chunk-UXREWVW4.js";
 import {
   ActivityStore,
   MaintenanceScheduler
-} from "./chunk-Z4RPXHJH.js";
+} from "./chunk-LYBIHM4N.js";
 import {
   runPeerProfileReasoner
 } from "./chunk-I74SUMNI.js";
@@ -32,7 +32,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-R47WINCY.js";
+} from "./chunk-UCKG36HO.js";
 import {
   SharedContextManager
 } from "./chunk-VI637ILW.js";
@@ -160,7 +160,7 @@ import {
 } from "./chunk-OH7QLI6W.js";
 import {
   ExtractionEngine
-} from "./chunk-LUNJ3WFO.js";
+} from "./chunk-ZK4BFABK.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-7BDZTALN.js";
@@ -176,7 +176,7 @@ import {
   getVerdictKind,
   judgeFactDurability,
   validateProcedureExtraction
-} from "./chunk-3DVBKTSO.js";
+} from "./chunk-HSZMX3ZJ.js";
 import {
   buildExplicitCueRecallSection
 } from "./chunk-TVIVY7KU.js";
@@ -184,7 +184,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-AUO2LJ3K.js";
+} from "./chunk-NLEH4RTB.js";
 import {
   planEpisodeWindowsWithFallback
 } from "./chunk-T3GIETKV.js";
@@ -209,14 +209,14 @@ import {
 } from "./chunk-VY47VI2T.js";
 import {
   refreshConvergedNamespaces
-} from "./chunk-E4MVQQVX.js";
+} from "./chunk-JPAKBNTM.js";
 import {
   builtInConnectorPackageSpecifier,
   ensureBuiltInWearableConnectors,
   getWearableConnector,
   listWearableConnectors,
   screenCandidateFact
-} from "./chunk-7QOO4LGC.js";
+} from "./chunk-3JZBPTLD.js";
 import {
   RoutingRulesStore
 } from "./chunk-TBUEE7XF.js";
@@ -226,14 +226,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-7KFIMGMP.js";
+} from "./chunk-ECLJ4LA2.js";
 import {
   ThreadingManager
 } from "./chunk-OJP3N7UK.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-AYDDB3XI.js";
+} from "./chunk-OCCHUEZB.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-NRLELHAY.js";
@@ -246,13 +246,13 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-OLWTCWQ2.js";
+} from "./chunk-YZJM6CLF.js";
 import {
   planNamespaceMaintenance
-} from "./chunk-MBDJJTAT.js";
+} from "./chunk-YDKF4MSJ.js";
 import {
   searchHarmonicRetrieval
-} from "./chunk-QXIQPCCN.js";
+} from "./chunk-UFR6HX7A.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -287,7 +287,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-RK4WXUI2.js";
+} from "./chunk-HF5BUTI6.js";
 import {
   BootstrapEngine
 } from "./chunk-MYVPLJOO.js";
@@ -305,7 +305,7 @@ import {
 } from "./chunk-6TBIWIAG.js";
 import {
   detectMeetings
-} from "./chunk-76PL4XLG.js";
+} from "./chunk-DPNXADEI.js";
 import {
   compileCorrectionRule,
   correctionsFilePath,
@@ -330,14 +330,14 @@ import {
 } from "./chunk-KD3QD3A5.js";
 import {
   MeetingsInputError
-} from "./chunk-BKYPJUQL.js";
+} from "./chunk-XGM3VQWG.js";
 import {
   WearablesInputError,
   describeErrorForOperator
 } from "./chunk-V7IZKJI3.js";
 import {
   NamespaceCatalog
-} from "./chunk-MRTUN665.js";
+} from "./chunk-DUEDOYZD.js";
 import {
   recordDreamsPhaseRun
 } from "./chunk-EQWEIIKQ.js";
@@ -354,7 +354,7 @@ import {
   filterRecallCandidates,
   isGenericRecallExcludedPath,
   isTopLevelArchivePath
-} from "./chunk-WN5FSGLE.js";
+} from "./chunk-AZLLH6YA.js";
 import {
   importCapsule
 } from "./chunk-6433HV72.js";
@@ -380,7 +380,7 @@ import {
 } from "./chunk-ZVZHG7AI.js";
 import {
   buildXraySnapshot
-} from "./chunk-G57LQRP6.js";
+} from "./chunk-MFOSZUIT.js";
 import {
   objectiveStateStoreOverrideForNamespace,
   searchObjectiveStateSnapshots
@@ -395,9 +395,6 @@ import {
 import {
   LocalLlmClient
 } from "./chunk-IVKIODHO.js";
-import {
-  buildProcedurePersistBody
-} from "./chunk-QDW3E4RD.js";
 import {
   shouldSkipImplicitExtraction
 } from "./chunk-7BEPVIH3.js";
@@ -411,7 +408,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-DHTQP334.js";
+} from "./chunk-CQBIN77D.js";
 import {
   GraphIndex
 } from "./chunk-BIJAWZYW.js";
@@ -464,7 +461,7 @@ import {
 } from "./chunk-CSAKJVXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-AYYGRVRP.js";
+} from "./chunk-IURMJBGP.js";
 import {
   QmdResultResolver,
   StorageManager,
@@ -483,7 +480,7 @@ import {
   reconstructFusionInputs,
   selfDeps,
   serializeFusionDay
-} from "./chunk-PAYGC3BD.js";
+} from "./chunk-THVI4Y7X.js";
 import {
   bodyIsEscaped,
   decodeTranscriptBody,
@@ -519,7 +516,7 @@ import {
 } from "./chunk-S2V7RUCL.js";
 import {
   confidenceTier
-} from "./chunk-NXKJHSDN.js";
+} from "./chunk-LBFFNDFM.js";
 import {
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive
@@ -587,6 +584,9 @@ import {
 import {
   assertExternalWikiRootOutsideMemoryDirCanonical
 } from "./chunk-JV3C2MNQ.js";
+import {
+  buildProcedurePersistBody
+} from "./chunk-QDW3E4RD.js";
 import {
   searchCausalTrajectories
 } from "./chunk-PP7R754B.js";
@@ -650,13 +650,13 @@ import {
   excludeSupportPassportPrivateMemories,
   isSupportPassportPrivateMemory
 } from "./chunk-XDL5CYZN.js";
+import {
+  ContentHashIndex
+} from "./chunk-JOEJG4SD.js";
 import {
   normalizeAttributePairs,
   stripAttributesSuffix
 } from "./chunk-JDSVLVCG.js";
-import {
-  ContentHashIndex
-} from "./chunk-JOEJG4SD.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -15652,7 +15652,7 @@ var OrchestratorInitCoordinator = class {
     if (signal.aborted) return;
     if (!this.deps.wearablesAutoSyncHandle && this.deps.config.wearables.enabled && this.deps.config.wearables.autoSyncEnabled && Object.values(this.deps.config.wearables.sources).some((source) => source.enabled)) {
       try {
-        const { startWearablesAutoSync } = await import("./auto-sync-H64ZCNIR.js");
+        const { startWearablesAutoSync } = await import("./auto-sync-XVMLL2RH.js");
         if (signal.aborted) return;
         this.deps.wearablesAutoSyncHandle = startWearablesAutoSync(
           {
@@ -27190,4 +27190,4 @@ export {
   blendGraphExpandedRecallScore,
   Orchestrator
 };
-//# sourceMappingURL=chunk-H5FW4S5Q.js.map
+//# sourceMappingURL=chunk-ZPOHEB5Z.js.map

package/dist/{chunk-RDFF2NAU.js → chunk-ZXBTTMGZ.js}

@@ -1,6 +1,16 @@
 import {
   estimateTokenCount
 } from "./chunk-TOTT6S2V.js";
+import {
+  SKILL_FILE_NAME,
+  renderSkillBundle
+} from "./chunk-236PXYG7.js";
+import {
+  isValidSkillSlug
+} from "./chunk-ZCUTSMR2.js";
+import {
+  pathIsInside
+} from "./chunk-GCASGYIO.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -16,8 +26,105 @@ import {
 import {
   createHash
 } from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+
+// src/connectors/materialize-paths.ts
 import fs from "fs";
 import path from "path";
+function ensureSafeManagedSubdir(memoriesDir, subdir, label) {
+  const memoriesReal = fs.realpathSync(memoriesDir);
+  try {
+    const stat = fs.lstatSync(subdir);
+    if (stat.isSymbolicLink()) {
+      throw new Error("is a symbolic link");
+    }
+    if (!stat.isDirectory()) {
+      throw new Error("is not a directory");
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw new Error(
+        `codex-materialize: unsafe ${label} directory at ${subdir}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    fs.mkdirSync(subdir, { recursive: true });
+  }
+  const subdirReal = fs.realpathSync(subdir);
+  if (!pathIsInside(memoriesReal, subdirReal)) {
+    throw new Error(
+      `codex-materialize: unsafe ${label} directory at ${subdir}: resolves outside ${memoriesDir}`
+    );
+  }
+  return path.normalize(subdir);
+}
+
+// src/connectors/materialize-skills.ts
+import fs2 from "fs";
+import path2 from "path";
+var SKILLS_SUBDIR = "skills";
+function planSkillFiles(bundles, previouslyProjectedSlugs) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const bundle of bundles ?? []) {
+    if (!isValidSkillSlug(bundle.slug) || seen.has(bundle.slug)) continue;
+    seen.add(bundle.slug);
+    files.push({ slug: bundle.slug, body: renderSkillBundle(bundle) });
+  }
+  const previous = previouslyProjectedSlugs.filter((slug) => isValidSkillSlug(slug));
+  return {
+    supplied: bundles !== void 0,
+    files,
+    retiredSlugs: bundles === void 0 ? [] : previous.filter((slug) => !seen.has(slug))
+  };
+}
+function skillFilePath(memoriesDir, slug) {
+  return path2.join(memoriesDir, SKILLS_SUBDIR, slug, SKILL_FILE_NAME);
+}
+function skillFileRelPath(slug) {
+  return path2.join(SKILLS_SUBDIR, slug, SKILL_FILE_NAME);
+}
+function retiredSkillsAlreadyRemoved(memoriesDir, retiredSlugs) {
+  return retiredSlugs.every((slug) => !fs2.existsSync(path2.join(memoriesDir, SKILLS_SUBDIR, slug)));
+}
+function stageSkillFiles(tmpDir, files) {
+  for (const file of files) {
+    const stagedDir = path2.join(tmpDir, SKILLS_SUBDIR, file.slug);
+    fs2.mkdirSync(stagedDir, { recursive: true });
+    fs2.writeFileSync(path2.join(stagedDir, SKILL_FILE_NAME), file.body);
+  }
+}
+function commitSkillFiles(memoriesDir, tmpDir, plan) {
+  if (!plan.supplied) return;
+  if (plan.files.length === 0 && plan.retiredSlugs.length === 0) return;
+  const skillsDir = ensureSafeManagedSubdir(memoriesDir, path2.join(memoriesDir, SKILLS_SUBDIR), SKILLS_SUBDIR);
+  for (const slug of plan.retiredSlugs) {
+    const retiredDir = path2.join(skillsDir, slug);
+    try {
+      if (fs2.lstatSync(retiredDir).isSymbolicLink()) continue;
+    } catch (err) {
+      if (err.code === "ENOENT") continue;
+      throw err;
+    }
+    try {
+      fs2.rmSync(retiredDir, { recursive: true, force: true });
+    } catch (err) {
+      throw new Error(
+        `codex-materialize: failed to remove retired skill ${slug}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  for (const file of plan.files) {
+    const destDir = path2.join(skillsDir, file.slug);
+    fs2.mkdirSync(destDir, { recursive: true });
+    fs2.renameSync(
+      path2.join(tmpDir, SKILLS_SUBDIR, file.slug, SKILL_FILE_NAME),
+      path2.join(destDir, SKILL_FILE_NAME)
+    );
+  }
+}
+
+// src/connectors/codex-materialize.ts
 var MATERIALIZE_VERSION = 1;
 var SENTINEL_FILE = ".remnic-managed";
 var TMP_DIR = ".remnic-tmp";
@@ -37,10 +144,10 @@ function materializeForNamespace(namespace, options) {
   const now = options.now ?? /* @__PURE__ */ new Date();
   const maxSummaryTokens = typeof options.maxSummaryTokens === "number" && options.maxSummaryTokens >= 0 ? options.maxSummaryTokens : 4500;
   const rolloutRetentionDays = typeof options.rolloutRetentionDays === "number" && options.rolloutRetentionDays >= 0 ? options.rolloutRetentionDays : 30;
-  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);
+  const sentinelPath = path3.join(memoriesDir, SENTINEL_FILE);
   const existingSentinel = readSentinel(sentinelPath);
   if (!existingSentinel) {
-    if (fs.existsSync(memoriesDir)) {
+    if (fs3.existsSync(memoriesDir)) {
       logger.warn(
         `sentinel ${SENTINEL_FILE} missing in ${memoriesDir}; skipping materialization to preserve hand-edits`
       );
@@ -59,7 +166,7 @@ function materializeForNamespace(namespace, options) {
       contentHash: ""
     };
   }
-  fs.mkdirSync(memoriesDir, { recursive: true });
+  fs3.mkdirSync(memoriesDir, { recursive: true });
   const memories = [...options.memories];
   const rolloutsSupplied = options.rolloutSummaries !== void 0;
   const rolloutSummaries = options.rolloutSummaries ?? [];
@@ -106,28 +213,32 @@ function materializeForNamespace(namespace, options) {
     name: `${sanitizeSlug(r.slug)}.md`,
     body: renderRolloutSummary(r)
   }));
-  const destRolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);
+  const destRolloutsDir = path3.join(memoriesDir, ROLLOUT_SUBDIR);
   const retainedRolloutNames = new Set(rolloutFiles.map((r) => r.name));
+  const skillPlan = planSkillFiles(options.skills, existingSentinel.projected_skills ?? []);
   const hash = computeContentHash({
     namespace,
     memorySummary,
     memoryMd,
     rawMemories,
-    rolloutFiles
+    rolloutFiles,
+    skillFiles: skillPlan.files
   });
   if (existingSentinel.content_hash === hash) {
     const requiredFiles = [
-      path.join(memoriesDir, "memory_summary.md"),
-      path.join(memoriesDir, "MEMORY.md"),
-      path.join(memoriesDir, "raw_memories.md"),
-      ...rolloutFiles.map((r) => path.join(memoriesDir, ROLLOUT_SUBDIR, r.name))
+      path3.join(memoriesDir, "memory_summary.md"),
+      path3.join(memoriesDir, "MEMORY.md"),
+      path3.join(memoriesDir, "raw_memories.md"),
+      ...rolloutFiles.map((r) => path3.join(memoriesDir, ROLLOUT_SUBDIR, r.name)),
+      ...skillPlan.files.map((s) => skillFilePath(memoriesDir, s.slug))
     ];
-    const allPresent = requiredFiles.every((f) => fs.existsSync(f));
+    const allPresent = requiredFiles.every((f) => fs3.existsSync(f));
     const rolloutsClean = !rolloutsSupplied || rolloutDirectoryMatchesRetainedSet(
-      ensureSafeRolloutsDir(memoriesDir, destRolloutsDir),
+      ensureSafeManagedSubdir(memoriesDir, destRolloutsDir, ROLLOUT_SUBDIR),
       retainedRolloutNames
     );
-    if (allPresent && rolloutsClean) {
+    const skillsClean = retiredSkillsAlreadyRemoved(memoriesDir, skillPlan.retiredSlugs);
+    if (allPresent && rolloutsClean && skillsClean) {
       logger.debug?.(`no-op materialization for namespace=${namespace} (hash unchanged)`);
       return {
         namespace,
@@ -144,46 +255,50 @@ function materializeForNamespace(namespace, options) {
     );
   }
   const runTag = `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-  const tmpDir = path.join(memoriesDir, `${TMP_DIR}-${runTag}`);
+  const tmpDir = path3.join(memoriesDir, `${TMP_DIR}-${runTag}`);
   const TMP_STALE_MS = 60 * 60 * 1e3;
   const wallClockMs = Date.now();
   try {
-    for (const entry of fs.readdirSync(memoriesDir, { withFileTypes: true })) {
+    for (const entry of fs3.readdirSync(memoriesDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
       if (!entry.name.startsWith(TMP_DIR)) continue;
-      const stalePath = path.join(memoriesDir, entry.name);
+      const stalePath = path3.join(memoriesDir, entry.name);
       try {
-        const stat = fs.statSync(stalePath);
+        const stat = fs3.statSync(stalePath);
         if (wallClockMs - stat.mtimeMs < TMP_STALE_MS) continue;
-        fs.rmSync(stalePath, { recursive: true, force: true });
+        fs3.rmSync(stalePath, { recursive: true, force: true });
       } catch {
       }
     }
   } catch {
   }
-  fs.mkdirSync(tmpDir, { recursive: true });
-  fs.mkdirSync(path.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });
+  fs3.mkdirSync(tmpDir, { recursive: true });
+  fs3.mkdirSync(path3.join(tmpDir, ROLLOUT_SUBDIR), { recursive: true });
   const filesWritten = [];
-  fs.writeFileSync(path.join(tmpDir, "memory_summary.md"), memorySummary);
+  fs3.writeFileSync(path3.join(tmpDir, "memory_summary.md"), memorySummary);
   filesWritten.push("memory_summary.md");
-  fs.writeFileSync(path.join(tmpDir, "MEMORY.md"), memoryMd);
+  fs3.writeFileSync(path3.join(tmpDir, "MEMORY.md"), memoryMd);
   filesWritten.push("MEMORY.md");
-  fs.writeFileSync(path.join(tmpDir, "raw_memories.md"), rawMemories);
+  fs3.writeFileSync(path3.join(tmpDir, "raw_memories.md"), rawMemories);
   filesWritten.push("raw_memories.md");
   for (const rollout of rolloutFiles) {
-    fs.writeFileSync(path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name), rollout.body);
-    filesWritten.push(path.join(ROLLOUT_SUBDIR, rollout.name));
+    fs3.writeFileSync(path3.join(tmpDir, ROLLOUT_SUBDIR, rollout.name), rollout.body);
+    filesWritten.push(path3.join(ROLLOUT_SUBDIR, rollout.name));
+  }
+  stageSkillFiles(tmpDir, skillPlan.files);
+  for (const skill of skillPlan.files) {
+    filesWritten.push(skillFileRelPath(skill.slug));
   }
   for (const rel of ["memory_summary.md", "MEMORY.md", "raw_memories.md"]) {
-    const src = path.join(tmpDir, rel);
-    const dest = path.join(memoriesDir, rel);
-    fs.renameSync(src, dest);
+    const src = path3.join(tmpDir, rel);
+    const dest = path3.join(memoriesDir, rel);
+    fs3.renameSync(src, dest);
   }
-  const safeDestRolloutsDir = ensureSafeRolloutsDir(memoriesDir, destRolloutsDir);
+  const safeDestRolloutsDir = ensureSafeManagedSubdir(memoriesDir, destRolloutsDir, ROLLOUT_SUBDIR);
   if (rolloutsSupplied) {
     let existingRollouts;
     try {
-      existingRollouts = fs.readdirSync(safeDestRolloutsDir, { withFileTypes: true });
+      existingRollouts = fs3.readdirSync(safeDestRolloutsDir, { withFileTypes: true });
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
       existingRollouts = [];
@@ -193,7 +308,7 @@ function materializeForNamespace(namespace, options) {
       if (!entry.name.endsWith(".md")) continue;
       if (retainedRolloutNames.has(entry.name)) continue;
       try {
-        fs.unlinkSync(path.join(safeDestRolloutsDir, entry.name));
+        fs3.unlinkSync(path3.join(safeDestRolloutsDir, entry.name));
       } catch (err) {
         throw new Error(
           `codex-materialize: failed to prune stale rollout summary ${entry.name}: ${err instanceof Error ? err.message : String(err)}`
@@ -202,19 +317,21 @@ function materializeForNamespace(namespace, options) {
     }
   }
   for (const rollout of rolloutFiles) {
-    const src = path.join(tmpDir, ROLLOUT_SUBDIR, rollout.name);
-    const dest = path.join(safeDestRolloutsDir, rollout.name);
-    fs.renameSync(src, dest);
+    const src = path3.join(tmpDir, ROLLOUT_SUBDIR, rollout.name);
+    const dest = path3.join(safeDestRolloutsDir, rollout.name);
+    fs3.renameSync(src, dest);
   }
+  commitSkillFiles(memoriesDir, tmpDir, skillPlan);
   const sentinel = {
     version: MATERIALIZE_VERSION,
     namespace,
     updated_at: now.toISOString(),
-    content_hash: hash
+    content_hash: hash,
+    projected_skills: skillPlan.supplied ? skillPlan.files.map((s) => s.slug) : existingSentinel.projected_skills ?? []
   };
   writeSentinelAtomically(sentinelPath, sentinel);
   try {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs3.rmSync(tmpDir, { recursive: true, force: true });
   } catch {
   }
   logger.info(
@@ -231,9 +348,9 @@ function materializeForNamespace(namespace, options) {
   };
 }
 function ensureSentinel(memoriesDir, namespace, now = /* @__PURE__ */ new Date()) {
-  fs.mkdirSync(memoriesDir, { recursive: true });
-  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);
-  if (fs.existsSync(sentinelPath)) {
+  fs3.mkdirSync(memoriesDir, { recursive: true });
+  const sentinelPath = path3.join(memoriesDir, SENTINEL_FILE);
+  if (fs3.existsSync(sentinelPath)) {
     readSentinel(sentinelPath);
     return;
   }
@@ -444,24 +561,24 @@ function validateMemoryMd(content) {
 }
 function resolveCodexHome(override) {
   if (override && override.trim().length > 0) {
-    return path.resolve(expandTildePath(override.trim()));
+    return path3.resolve(expandTildePath(override.trim()));
   }
   const fromEnv = readEnvVar("CODEX_HOME");
   if (fromEnv && fromEnv.trim().length > 0) {
-    return path.resolve(expandTildePath(fromEnv.trim()));
+    return path3.resolve(expandTildePath(fromEnv.trim()));
   }
-  return path.resolve(resolveHomeDir(), ".codex");
+  return path3.resolve(resolveHomeDir(), ".codex");
 }
 function resolveCodexMemoriesDir(codexHome) {
-  return path.join(resolveCodexHome(codexHome), "memories");
+  return path3.join(resolveCodexHome(codexHome), "memories");
 }
 function hasCodexMaterializeSentinel(codexHome) {
-  return readSentinel(path.join(resolveCodexMemoriesDir(codexHome), SENTINEL_FILE)) !== null;
+  return readSentinel(path3.join(resolveCodexMemoriesDir(codexHome), SENTINEL_FILE)) !== null;
 }
 function rolloutDirectoryMatchesRetainedSet(rolloutsDir, retainedNames) {
   let entries;
   try {
-    entries = fs.readdirSync(rolloutsDir, { withFileTypes: true });
+    entries = fs3.readdirSync(rolloutsDir, { withFileTypes: true });
   } catch {
     return retainedNames.size === 0;
   }
@@ -472,49 +589,21 @@ function rolloutDirectoryMatchesRetainedSet(rolloutsDir, retainedNames) {
   }
   return true;
 }
-function isPathInside(parent, child) {
-  const relative = path.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
-}
-function ensureSafeRolloutsDir(memoriesDir, rolloutsDir) {
-  const memoriesReal = fs.realpathSync(memoriesDir);
-  try {
-    const stat = fs.lstatSync(rolloutsDir);
-    if (stat.isSymbolicLink()) {
-      throw new Error("is a symbolic link");
-    }
-    if (!stat.isDirectory()) {
-      throw new Error("is not a directory");
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      throw new Error(
-        `codex-materialize: unsafe ${ROLLOUT_SUBDIR} directory at ${rolloutsDir}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    fs.mkdirSync(rolloutsDir, { recursive: true });
-  }
-  const rolloutsReal = fs.realpathSync(rolloutsDir);
-  if (!isPathInside(memoriesReal, rolloutsReal)) {
-    throw new Error(
-      `codex-materialize: unsafe ${ROLLOUT_SUBDIR} directory at ${rolloutsDir}: resolves outside ${memoriesDir}`
-    );
-  }
-  return rolloutsDir;
-}
 function readSentinel(sentinelPath) {
-  if (!fs.existsSync(sentinelPath)) return null;
+  if (!fs3.existsSync(sentinelPath)) return null;
   try {
-    const raw = fs.readFileSync(sentinelPath, "utf-8");
+    const raw = fs3.readFileSync(sentinelPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || typeof parsed.version !== "number" || typeof parsed.namespace !== "string" || typeof parsed.updated_at !== "string" || typeof parsed.content_hash !== "string") {
       throw new Error("invalid sentinel schema");
     }
+    const projected = Array.isArray(parsed.projected_skills) ? parsed.projected_skills.filter((slug) => typeof slug === "string") : [];
     return {
       version: parsed.version,
       namespace: parsed.namespace,
       updated_at: parsed.updated_at,
-      content_hash: parsed.content_hash
+      content_hash: parsed.content_hash,
+      projected_skills: projected
     };
   } catch (err) {
     throw new Error(
@@ -525,14 +614,14 @@ function readSentinel(sentinelPath) {
 function writeSentinelAtomically(sentinelPath, sentinel) {
   const tmpPath = `${sentinelPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
   try {
-    fs.writeFileSync(tmpPath, `${JSON.stringify(sentinel, null, 2)}
+    fs3.writeFileSync(tmpPath, `${JSON.stringify(sentinel, null, 2)}
 `, {
       flag: "wx"
     });
-    fs.renameSync(tmpPath, sentinelPath);
+    fs3.renameSync(tmpPath, sentinelPath);
   } catch (err) {
     try {
-      fs.rmSync(tmpPath, { force: true });
+      fs3.rmSync(tmpPath, { force: true });
     } catch {
     }
     throw err;
@@ -658,22 +747,29 @@ function computeContentHash(input) {
 `);
     hash.update(r.body);
   }
+  const sortedSkills = [...input.skillFiles].sort((a, b) => a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+  for (const s of sortedSkills) {
+    hash.update(`
+---skill:${s.slug}---
+`);
+    hash.update(s.body);
+  }
   return hash.digest("hex");
 }
 function describeMemoriesDir(memoriesDir) {
-  if (!fs.existsSync(memoriesDir)) return null;
-  const sentinelPath = path.join(memoriesDir, SENTINEL_FILE);
+  if (!fs3.existsSync(memoriesDir)) return null;
+  const sentinelPath = path3.join(memoriesDir, SENTINEL_FILE);
   const sentinel = readSentinel(sentinelPath);
   const files = [];
-  for (const entry of fs.readdirSync(memoriesDir, { withFileTypes: true })) {
+  for (const entry of fs3.readdirSync(memoriesDir, { withFileTypes: true })) {
     if (entry.isFile() && OWNED_FILES.has(entry.name)) files.push(entry.name);
   }
-  const rolloutsDir = path.join(memoriesDir, ROLLOUT_SUBDIR);
-  if (fs.existsSync(rolloutsDir)) {
+  const rolloutsDir = path3.join(memoriesDir, ROLLOUT_SUBDIR);
+  if (fs3.existsSync(rolloutsDir)) {
     try {
-      for (const entry of fs.readdirSync(rolloutsDir, { withFileTypes: true })) {
+      for (const entry of fs3.readdirSync(rolloutsDir, { withFileTypes: true })) {
         if (entry.isFile() && entry.name.endsWith(".md")) {
-          files.push(path.join(ROLLOUT_SUBDIR, entry.name));
+          files.push(path3.join(ROLLOUT_SUBDIR, entry.name));
         }
       }
     } catch {
@@ -704,4 +800,4 @@ export {
   truncateToTokenBudget,
   describeMemoriesDir
 };
-//# sourceMappingURL=chunk-RDFF2NAU.js.map
+//# sourceMappingURL=chunk-ZXBTTMGZ.js.map