@promptscript/cli 1.13.1 → 1.13.2

package/index.js

@@ -1415,6 +1415,12 @@ var init_mapper = __esm({
 });
 
 // packages/importer/src/emitter.ts
+function resolveQuoteDelimiter(content) {
+  const matches = content.match(/"+/g);
+  if (!matches) return '"""';
+  const maxRun = matches.reduce((max, m) => Math.max(max, m.length), 0);
+  return '"'.repeat(Math.max(3, maxRun + 1));
+}
 function emitPrs(sections, options) {
   const lines = [];
   lines.push("@meta {");
@@ -1440,11 +1446,12 @@ function emitPrs(sections, options) {
         lines.push(`  ${entryName}: {`);
         lines.push(`    applyTo: [${applyToStr}]`);
         lines.push(`    description: "${description}"`);
-        lines.push(`    content: """`);
+        const contentDelimiter2 = resolveQuoteDelimiter(section.content);
+        lines.push(`    content: ${contentDelimiter2}`);
         for (const contentLine of section.content.split("\n")) {
           lines.push(`    ${contentLine}`);
         }
-        lines.push(`    """`);
+        lines.push(`    ${contentDelimiter2}`);
         lines.push(`  }`);
       }
       lines.push(`}`);
@@ -1453,11 +1460,12 @@ function emitPrs(sections, options) {
     }
     lines.push(`@${block} {`);
     const mergedContent = blockSections.map((s) => s.content).join("\n\n");
-    lines.push(`  """`);
+    const contentDelimiter = resolveQuoteDelimiter(mergedContent);
+    lines.push(`  ${contentDelimiter}`);
     for (const contentLine of mergedContent.split("\n")) {
       lines.push(`    ${contentLine}`);
     }
-    lines.push(`  """`);
+    lines.push(`  ${contentDelimiter}`);
     lines.push("}");
   }
   lines.push("");
@@ -1497,11 +1505,12 @@ function emitModularFiles(blocks, options) {
         lines.push("# REVIEW: low confidence -- verify this mapping");
       }
       lines.push(`@${block.targetBlock} {`);
-      lines.push('  """');
+      const blockDelimiter = resolveQuoteDelimiter(block.content);
+      lines.push(`  ${blockDelimiter}`);
       for (const contentLine of block.content.split("\n")) {
         lines.push(`    ${contentLine}`);
       }
-      lines.push('  """');
+      lines.push(`  ${blockDelimiter}`);
       lines.push("}");
       lines.push("");
     }
@@ -1525,11 +1534,12 @@ function emitModularFiles(blocks, options) {
       projectLines.push(comment);
     }
     projectLines.push("@identity {");
-    projectLines.push('  """');
+    const identityDelimiter = resolveQuoteDelimiter(identity.content);
+    projectLines.push(`  ${identityDelimiter}`);
     for (const line of identity.content.split("\n")) {
       projectLines.push(`    ${line}`);
     }
-    projectLines.push('  """');
+    projectLines.push(`  ${identityDelimiter}`);
     projectLines.push("}");
   }
   projectLines.push("");
@@ -8922,6 +8932,7 @@ var init_parser2 = __esm({
             { ALT: () => this.SUBRULE(this.block) }
           ])
         );
+        this.CONSUME(EOF);
       });
       /**
        * metaBlock
@@ -10093,6 +10104,12 @@ ${s.content}`);
     reviewComments: []
   };
 }
+function isStructuralMarker(line) {
+  const trimmed = line.trim();
+  if (/^```[^\s`]*$/.test(trimmed)) return true;
+  if (/^(---|\*\*\*|___)$/.test(trimmed)) return true;
+  return false;
+}
 function mergeUnion(sections) {
   const seenLines = /* @__PURE__ */ new Set();
   const uniqueLines = [];
@@ -10102,6 +10119,10 @@ function mergeUnion(sections) {
     for (const line of lines) {
       const normalized = line.trim().replace(/\s+/g, " ");
       if (normalized.length === 0) continue;
+      if (isStructuralMarker(line)) {
+        uniqueLines.push(line);
+        continue;
+      }
       if (seenLines.has(normalized)) {
         deduped++;
         continue;
@@ -11783,11 +11804,18 @@ var init_base_formatter = __esm({
       referenceProvenance(sourcePath) {
         return `<!-- from: ${sourcePath} -->`;
       }
+      /**
+       * Check if a name is safe for use in file paths.
+       * Rejects path traversal sequences and path separators.
+       */
+      isSafeName(name) {
+        return !name.includes("..") && !name.includes("/") && !name.includes("\\");
+      }
       /**
        * Check if a skill name is safe for use in file paths.
        */
       isSafeSkillName(name) {
-        return !name.includes("..") && !name.includes("/") && !name.includes("\\");
+        return this.isSafeName(name);
       }
       /**
        * Render content inside a code fence, using a longer fence if the content
@@ -11961,9 +11989,11 @@ var init_markdown_instruction_formatter = __esm({
             if ("type" in value && value["type"] === "TextContent") {
               const content = this.valueToString(value);
               if (content.includes("\n")) {
+                const cmdName = name.replace(/^\/+/, "");
+                if (!this.isSafeName(cmdName)) continue;
                 commands.push({
-                  name: name.replace(/^\/+/, ""),
-                  description: name.replace(/^\/+/, ""),
+                  name: cmdName,
+                  description: cmdName,
                   content
                 });
               }
@@ -11971,8 +12001,10 @@ var init_markdown_instruction_formatter = __esm({
             }
             const obj = value;
             if (obj["prompt"] === true || obj["content"]) {
+              const cmdName = name.replace(/^\/+/, "");
+              if (!this.isSafeName(cmdName)) continue;
               commands.push({
-                name: name.replace(/^\/+/, ""),
+                name: cmdName,
                 description: obj["description"] ? this.valueToString(obj["description"]) : name,
                 argumentHint: obj["argumentHint"] ? this.valueToString(obj["argumentHint"]) : void 0,
                 content: obj["content"] ? this.valueToString(obj["content"]) : ""
@@ -18401,11 +18433,21 @@ function detectTools() {
   );
 }
 async function readSettingsFile(path) {
+  let content;
+  try {
+    content = await readFile4(path, "utf-8");
+  } catch (err) {
+    const nodeErr = err;
+    if (nodeErr.code === "ENOENT") {
+      return {};
+    }
+    throw err;
+  }
   try {
-    const content = await readFile4(path, "utf-8");
     return JSON.parse(content);
-  } catch {
-    return {};
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse settings file ${path}: ${message}`, { cause: err });
   }
 }
 async function writeSettingsFile(path, data) {
@@ -20882,9 +20924,9 @@ var require_rate_limit = __commonJS({
       let ttl = 0;
       let ttlInSeconds = 0;
       try {
-        const res = await new Promise((resolve22, reject) => {
+        const res = await new Promise((resolve24, reject) => {
           store.incr(key, (err, res2) => {
-            err ? reject(err) : resolve22(res2);
+            err ? reject(err) : resolve24(res2);
           }, timeWindow, max);
         });
         current = res.current;
@@ -21053,17 +21095,43 @@ var init_config2 = __esm({
 });
 
 // packages/server/src/path-guard.ts
-import { resolve as resolve21, relative as relative4, isAbsolute as isAbsolute6 } from "path";
-function resolveSafePath(workspace, requestedPath) {
+import { resolve as resolve23, relative as relative6, isAbsolute as isAbsolute6, dirname as dirname15, basename as basename16 } from "path";
+import { realpath as realpath2 } from "fs/promises";
+async function resolveSafePath(workspace, requestedPath) {
   const decoded = decodeURIComponent(requestedPath);
   if (isAbsolute6(decoded)) {
     throw new PathTraversalError(requestedPath);
   }
-  const resolved = resolve21(workspace, decoded);
-  const rel = relative4(workspace, resolved);
+  const resolved = resolve23(workspace, decoded);
+  const rel = relative6(workspace, resolved);
   if (rel.startsWith("..") || isAbsolute6(rel)) {
     throw new PathTraversalError(requestedPath);
   }
+  let realWorkspace;
+  try {
+    realWorkspace = await realpath2(workspace);
+  } catch {
+    realWorkspace = workspace;
+  }
+  let real;
+  try {
+    real = await realpath2(resolved);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      try {
+        const realParent = await realpath2(dirname15(resolved));
+        real = resolve23(realParent, basename16(resolved));
+      } catch {
+        return resolved;
+      }
+    } else {
+      throw err;
+    }
+  }
+  const realRel = relative6(realWorkspace, real);
+  if (realRel.startsWith("..") || isAbsolute6(realRel)) {
+    throw new PathTraversalError(requestedPath);
+  }
   return resolved;
 }
 var PathTraversalError;
@@ -21081,7 +21149,7 @@ var init_path_guard = __esm({
 
 // packages/server/src/routes/files.ts
 import { readFile as readFile25, writeFile as writeFile13, unlink as unlink2, stat as stat3, mkdir as mkdir10 } from "fs/promises";
-import { dirname as dirname15 } from "path";
+import { dirname as dirname16 } from "path";
 import fg from "fast-glob";
 function registerRoutes(app, workspace, readOnly) {
   app.get("/api/files", async () => {
@@ -21100,7 +21168,7 @@ function registerRoutes(app, workspace, readOnly) {
   app.get("/api/files/*", async (request, reply) => {
     const filePath = request.params["*"];
     try {
-      const resolved = resolveSafePath(workspace, filePath);
+      const resolved = await resolveSafePath(workspace, filePath);
       const content = await readFile25(resolved, "utf-8");
       return { path: filePath, content };
     } catch (err) {
@@ -21117,7 +21185,7 @@ function registerRoutes(app, workspace, readOnly) {
       if (readOnly) return reply.status(403).send({ error: "Read-only mode" });
       const filePath = request.params["*"];
       try {
-        const resolved = resolveSafePath(workspace, filePath);
+        const resolved = await resolveSafePath(workspace, filePath);
         await writeFile13(resolved, request.body.content, "utf-8");
         return { path: filePath, status: "updated" };
       } catch (err) {
@@ -21135,13 +21203,13 @@ function registerRoutes(app, workspace, readOnly) {
       if (readOnly) return reply.status(403).send({ error: "Read-only mode" });
       const filePath = request.params["*"];
       try {
-        const resolved = resolveSafePath(workspace, filePath);
+        const resolved = await resolveSafePath(workspace, filePath);
         try {
           await stat3(resolved);
           return reply.status(409).send({ error: "File already exists" });
         } catch {
         }
-        await mkdir10(dirname15(resolved), { recursive: true });
+        await mkdir10(dirname16(resolved), { recursive: true });
         await writeFile13(resolved, request.body.content, "utf-8");
         return reply.status(201).send({ path: filePath, status: "created" });
       } catch (err) {
@@ -21156,7 +21224,7 @@ function registerRoutes(app, workspace, readOnly) {
     if (readOnly) return reply.status(403).send({ error: "Read-only mode" });
     const filePath = request.params["*"];
     try {
-      const resolved = resolveSafePath(workspace, filePath);
+      const resolved = await resolveSafePath(workspace, filePath);
       await unlink2(resolved);
       return { path: filePath, status: "deleted" };
     } catch (err) {
@@ -21179,7 +21247,7 @@ var init_files = __esm({
 
 // packages/server/src/watcher.ts
 import { watch } from "chokidar";
-import { relative as relative5 } from "path";
+import { relative as relative7 } from "path";
 function isWatchedFile(filePath) {
   const base = filePath.split("/").pop() ?? "";
   if (CONFIG_FILENAMES2.has(base)) return true;
@@ -21195,15 +21263,15 @@ function createFileWatcher(workspace, watchPaths, onEvent) {
   });
   watcher.on("add", (filePath) => {
     if (!ready || !isWatchedFile(filePath)) return;
-    onEvent({ type: "file:created", path: relative5(workspace, filePath) });
+    onEvent({ type: "file:created", path: relative7(workspace, filePath) });
   });
   watcher.on("change", (filePath) => {
     if (!ready || !isWatchedFile(filePath)) return;
-    onEvent({ type: "file:changed", path: relative5(workspace, filePath) });
+    onEvent({ type: "file:changed", path: relative7(workspace, filePath) });
   });
   watcher.on("unlink", (filePath) => {
     if (!ready || !isWatchedFile(filePath)) return;
-    onEvent({ type: "file:deleted", path: relative5(workspace, filePath) });
+    onEvent({ type: "file:deleted", path: relative7(workspace, filePath) });
   });
   return watcher;
 }
@@ -21225,7 +21293,20 @@ async function createServer(options) {
     origin: options.corsOrigin
   });
   await app.register(import_rate_limit.default, { max: 1e3, timeWindow: "1 minute" });
-  await app.register(fastifyWebsocket);
+  await app.register(fastifyWebsocket, {
+    options: {
+      // Validate Origin header to prevent cross-origin WebSocket connections.
+      // Browser WebSockets don't enforce CORS, so we must check server-side.
+      verifyClient: (info, callback) => {
+        const origin = info.req.headers.origin;
+        if (origin && origin !== options.corsOrigin && options.corsOrigin !== "*") {
+          callback(false, 403, "Origin not allowed");
+          return;
+        }
+        callback(true);
+      }
+    }
+  });
   registerHealthRoute(app);
   registerConfigRoute(
     app,
@@ -21366,12 +21447,12 @@ var init_migrate = __esm({
 init_src();
 init_init();
 import { Command } from "commander";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname16 } from "path";
+import { fileURLToPath as fileURLToPath4, pathToFileURL } from "url";
+import { dirname as dirname17 } from "path";
 
 // packages/cli/src/commands/compile.ts
 init_src();
-import { resolve as resolve8, dirname as dirname9, isAbsolute as isAbsolute5 } from "path";
+import { resolve as resolve10, dirname as dirname9, isAbsolute as isAbsolute5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile12 } from "fs/promises";
 import { existsSync as existsSync12 } from "fs";
@@ -21383,6 +21464,68 @@ init_env_config();
 import { readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import { parse as parseYaml4 } from "yaml";
+
+// packages/cli/src/config/merge-config.ts
+function deepMergeRegistry(target, source) {
+  if (!source) return target;
+  if (!target) return source;
+  const merged = { ...target };
+  if (source.path !== void 0) merged.path = source.path;
+  if (source.url !== void 0) merged.url = source.url;
+  if (source.git) {
+    const mergedAuth = source.git.auth ?? merged.git?.auth;
+    merged.git = {
+      ...merged.git,
+      ...source.git,
+      ...mergedAuth ? { auth: mergedAuth } : {}
+    };
+  }
+  if (source.cache) {
+    merged.cache = { ...merged.cache, ...source.cache };
+  }
+  if (source.auth) {
+    merged.auth = { ...merged.auth, ...source.auth };
+  }
+  return merged;
+}
+function userConfigToProjectRegistry(userRegistry) {
+  const registry2 = {};
+  if (userRegistry.git) {
+    registry2.git = {
+      url: userRegistry.git.url,
+      ...userRegistry.git.fallbackUrl ? { fallbackUrl: userRegistry.git.fallbackUrl } : {},
+      ...userRegistry.git.ref ? { ref: userRegistry.git.ref } : {},
+      ...userRegistry.git.path ? { path: userRegistry.git.path } : {},
+      ...userRegistry.git.auth ? { auth: userRegistry.git.auth } : {}
+    };
+  }
+  if (userRegistry.url) {
+    registry2.url = userRegistry.url;
+  }
+  if (userRegistry.cache) {
+    registry2.cache = { ...userRegistry.cache };
+  }
+  return registry2;
+}
+function mergeConfigs(userConfig, projectConfig, envOverrides, cliFlags) {
+  const merged = { ...projectConfig };
+  if (userConfig.registry) {
+    const userRegistry = userConfigToProjectRegistry(userConfig.registry);
+    merged.registry = deepMergeRegistry(userRegistry, merged.registry);
+  }
+  if (envOverrides.registry) {
+    merged.registry = deepMergeRegistry(merged.registry, envOverrides.registry);
+  }
+  if (cliFlags?.registry) {
+    merged.registry = deepMergeRegistry(merged.registry, cliFlags.registry);
+  }
+  if (cliFlags?.targets) {
+    merged.targets = cliFlags.targets;
+  }
+  return merged;
+}
+
+// packages/cli/src/config/loader.ts
 var CONFIG_FILES = [
   "promptscript.yaml",
   "promptscript.yml",
@@ -21435,6 +21578,12 @@ async function loadConfig(customPath) {
     throw new Error(`Failed to parse ${configFile}: ${message}`, { cause: error });
   }
 }
+async function loadEffectiveConfig(customPath, cliFlags) {
+  const userConfig = await loadUserConfig();
+  const projectConfig = await loadConfig(customPath);
+  const envOverrides = loadEnvOverrides();
+  return mergeConfigs(userConfig, projectConfig, envOverrides, cliFlags);
+}
 
 // packages/cli/src/commands/compile.ts
 init_loader();
@@ -21498,8 +21647,8 @@ init_src4();
 init_src2();
 init_src();
 import { existsSync as existsSync9 } from "fs";
-import { lstat as lstat3, readdir as readdir4, readFile as readFile11 } from "fs/promises";
-import { basename as basename11, dirname as dirname7, join as join8 } from "path";
+import { lstat as lstat4, readdir as readdir4, readFile as readFile11 } from "fs/promises";
+import { basename as basename11, dirname as dirname7, join as join8, relative as relative4, resolve as resolve9 } from "path";
 
 // packages/resolver/src/loader.ts
 init_src();
@@ -23042,10 +23191,10 @@ function parseSkillIgnore(content) {
   return { patterns };
 }
 function isIgnoredByRules(relPath, rules) {
-  const basename16 = relPath.split("/").pop() ?? relPath;
+  const basename17 = relPath.split("/").pop() ?? relPath;
   let ignored = false;
   for (const { regex, matchPath, negated } of rules.patterns) {
-    const target = matchPath ? relPath : basename16;
+    const target = matchPath ? relPath : basename17;
     if (regex.test(target)) {
       ignored = !negated;
     }
@@ -24605,6 +24754,27 @@ var GitRegistry = class {
     await this.cacheManager.remove(this.url, targetRef);
     await this.ensureCloned(targetRef);
   }
+  /**
+   * Checkout a specific commit in an already-cloned repository.
+   * Used to enforce lockfile pinning: after cloning at a tag/branch,
+   * checkout the exact commit recorded in the lockfile.
+   *
+   * @param targetDir - Path to the cloned repository
+   * @param commit - Commit hash to checkout
+   */
+  async checkoutCommit(targetDir, commit) {
+    const git = this.createGit(targetDir);
+    try {
+      await git.fetch(["origin", commit, "--depth=1"]);
+    } catch {
+      try {
+        await git.fetch(["--unshallow"]);
+      } catch {
+        await git.fetch(["origin"]);
+      }
+    }
+    await git.checkout(commit);
+  }
   /**
    * Get the current commit hash for a ref.
    *
@@ -25134,8 +25304,16 @@ async function validateRemoteAccess(repoUrl) {
 }
 
 // packages/resolver/src/registry-cache.ts
-import { mkdir as mkdir3, stat, writeFile as writeFile3, readFile as readFile9 } from "fs/promises";
-import { join as join7 } from "path";
+import { mkdir as mkdir3, stat, writeFile as writeFile3, readFile as readFile9, lstat as lstat2 } from "fs/promises";
+import { join as join7, resolve as resolve7, relative as relative3 } from "path";
+function validatePathComponent(component, label) {
+  if (component.includes("..")) {
+    throw new Error(`Invalid ${label}: contains parent directory traversal (..)`);
+  }
+  if (component.startsWith("/")) {
+    throw new Error(`Invalid ${label}: absolute paths are not allowed`);
+  }
+}
 var RegistryCache = class {
   constructor(baseDir) {
     this.baseDir = baseDir;
@@ -25143,7 +25321,13 @@ var RegistryCache = class {
   baseDir;
   getCachePath(repoUrl, version) {
     const normalized = repoUrl.replace(/^(https?:\/\/|git@|git:\/\/)/, "").replace(":", "/");
-    return join7(this.baseDir, "registries", normalized, version);
+    validatePathComponent(version, "version");
+    const result = join7(this.baseDir, "registries", normalized, version);
+    const rel = relative3(resolve7(this.baseDir), resolve7(result));
+    if (rel.startsWith("..")) {
+      throw new Error(`Path traversal detected: version "${version}" escapes cache root`);
+    }
+    return result;
   }
   async has(repoUrl, version) {
     try {
@@ -25157,8 +25341,19 @@ var RegistryCache = class {
   async set(repoUrl, version, commit) {
     const cachePath = this.getCachePath(repoUrl, version);
     await mkdir3(cachePath, { recursive: true });
+    const metaPath = join7(cachePath, ".prs-registry-meta.json");
+    try {
+      const statResult = await lstat2(metaPath);
+      if (statResult.isSymbolicLink()) {
+        throw new Error(
+          `Refusing to write metadata: ${metaPath} is a symlink (possible supply-chain attack)`
+        );
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
     const meta = { commit, cachedAt: Date.now() };
-    await writeFile3(join7(cachePath, ".prs-registry-meta.json"), JSON.stringify(meta, null, 2));
+    await writeFile3(metaPath, JSON.stringify(meta, null, 2));
     return cachePath;
   }
   async isStale(repoUrl, version, ttlMs) {
@@ -25207,9 +25402,16 @@ var RegistryCache = class {
   }
 };
 
+// packages/resolver/src/reference-hasher.ts
+import { createHash as createHash2 } from "crypto";
+function hashContent(content) {
+  const hex = createHash2("sha256").update(content).digest("hex");
+  return `sha256-${hex}`;
+}
+
 // packages/resolver/src/auto-discovery.ts
-import { readFile as readFile10, readdir as readdir3, access as access2, lstat as lstat2 } from "fs/promises";
-import { resolve as resolve7, basename as basename10 } from "path";
+import { readFile as readFile10, readdir as readdir3, access as access2, lstat as lstat3 } from "fs/promises";
+import { resolve as resolve8, basename as basename10 } from "path";
 var CONTEXT_FILES = ["CLAUDE.md", ".clinerules", ".cursorrules"];
 async function fileExists2(path) {
   try {
@@ -25245,9 +25447,9 @@ async function discoverSkills(dir) {
   const properties = {};
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    let skillMdPath = resolve7(dir, entry.name, "SKILL.md");
+    let skillMdPath = resolve8(dir, entry.name, "SKILL.md");
     if (!await fileExists2(skillMdPath)) {
-      const dirnameMdPath = resolve7(dir, entry.name, `${entry.name}.md`);
+      const dirnameMdPath = resolve8(dir, entry.name, `${entry.name}.md`);
       if (await fileExists2(dirnameMdPath)) {
         skillMdPath = dirnameMdPath;
       } else {
@@ -25274,7 +25476,7 @@ async function discoverSkills(dir) {
   return Object.keys(properties).length > 0 ? properties : null;
 }
 async function discoverRootSkill(dir) {
-  const skillMdPath = resolve7(dir, "SKILL.md");
+  const skillMdPath = resolve8(dir, "SKILL.md");
   if (!await fileExists2(skillMdPath)) return null;
   try {
     const raw = await readFile10(skillMdPath, "utf-8");
@@ -25305,9 +25507,9 @@ async function discoverAgents(dir) {
   const properties = {};
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const fullPath = resolve7(dir, entry.name);
+    const fullPath = resolve8(dir, entry.name);
     try {
-      const stat4 = await lstat2(fullPath);
+      const stat4 = await lstat3(fullPath);
       if (stat4.isSymbolicLink()) continue;
       const raw = await readFile10(fullPath, "utf-8");
       const fm = parseFrontmatter(raw);
@@ -25341,9 +25543,9 @@ async function discoverCommands(dir) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
     if (entry.name === "SKILL.md") continue;
-    const fullPath = resolve7(dir, entry.name);
+    const fullPath = resolve8(dir, entry.name);
     try {
-      const stat4 = await lstat2(fullPath);
+      const stat4 = await lstat3(fullPath);
       if (stat4.isSymbolicLink()) continue;
       const raw = await readFile10(fullPath, "utf-8");
       const fm = parseFrontmatter(raw);
@@ -25358,7 +25560,7 @@ async function discoverCommands(dir) {
 }
 async function discoverContext(dir) {
   for (const fileName of CONTEXT_FILES) {
-    const fullPath = resolve7(dir, fileName);
+    const fullPath = resolve8(dir, fileName);
     if (!await fileExists2(fullPath)) continue;
     try {
       const content = await readFile10(fullPath, "utf-8");
@@ -25375,7 +25577,7 @@ var AGENT_WRAPPER_DIRS = ["agents"];
 var COMMAND_WRAPPER_DIRS = ["commands"];
 async function safeIsDirectory(dir) {
   try {
-    const stat4 = await lstat2(dir);
+    const stat4 = await lstat3(dir);
     return stat4.isDirectory();
   } catch {
     return false;
@@ -25388,7 +25590,7 @@ async function discoverNativeContent(dir) {
   const subSkills = await discoverSkills(dir);
   const wrappedSkillResults = await Promise.all(
     SKILL_WRAPPER_DIRS.map(async (name) => {
-      const candidate = resolve7(dir, name);
+      const candidate = resolve8(dir, name);
       if (!await safeIsDirectory(candidate)) return null;
       return discoverSkills(candidate);
     })
@@ -25409,7 +25611,7 @@ async function discoverNativeContent(dir) {
   const rootAgents = await discoverAgents(dir) ?? {};
   const wrappedAgents = {};
   for (const name of AGENT_WRAPPER_DIRS) {
-    const candidate = resolve7(dir, name);
+    const candidate = resolve8(dir, name);
     if (await safeIsDirectory(candidate)) {
       const found = await discoverAgents(candidate);
       if (found) Object.assign(wrappedAgents, found);
@@ -25422,7 +25624,7 @@ async function discoverNativeContent(dir) {
   const rootCommands = await discoverCommands(dir) ?? {};
   const wrappedCommands = {};
   for (const name of COMMAND_WRAPPER_DIRS) {
-    const candidate = resolve7(dir, name);
+    const candidate = resolve8(dir, name);
     if (await safeIsDirectory(candidate)) {
       const found = await discoverCommands(candidate);
       if (found) Object.assign(wrappedCommands, found);
@@ -25889,23 +26091,56 @@ var Resolver = class {
       const lockEntry = this.options.lockfile?.dependencies[repoUrl];
       const pinnedTag = lockEntry?.version ?? (version || void 0);
       const tag = pinnedTag ?? "main";
+      const lockedCommit = lockEntry?.commit && /^[0-9a-f]{40}$/.test(lockEntry.commit) && !/^0{40}$/.test(lockEntry.commit) ? lockEntry.commit : null;
       const hasCached = await this.registryCache.has(repoUrl, effectiveVersion);
       let cachePath;
       if (hasCached) {
         this.logger.debug(`Registry cache hit: ${repoUrl}@${effectiveVersion}`);
         cachePath = this.registryCache.getCachePath(repoUrl, effectiveVersion);
+        if (lockedCommit) {
+          try {
+            const cachedMeta = await this.registryCache.getMeta(repoUrl, effectiveVersion);
+            if (cachedMeta && cachedMeta.commit !== lockedCommit) {
+              this.logger.verbose(
+                `Lockfile commit mismatch for ${repoUrl}: cached=${cachedMeta.commit}, locked=${lockedCommit}. Re-cloning.`
+              );
+              const fallbackRepoUrl = this.options.registries ? findFallbackUrl(repoUrl, this.options.registries) : void 0;
+              await this.gitRegistry.cloneAtTag(repoUrl, tag, cachePath, fallbackRepoUrl);
+              await this.gitRegistry.checkoutCommit(cachePath, lockedCommit);
+              await this.registryCache.set(repoUrl, effectiveVersion, lockedCommit);
+            }
+          } catch (err) {
+            this.logger.debug(`Lockfile commit verification failed: ${err}`);
+          }
+        }
       } else {
         this.logger.verbose(`Registry cache miss, cloning: ${repoUrl}@${tag}`);
         cachePath = this.registryCache.getCachePath(repoUrl, effectiveVersion);
         const fallbackRepoUrl = this.options.registries ? findFallbackUrl(repoUrl, this.options.registries) : void 0;
         await this.gitRegistry.cloneAtTag(repoUrl, tag, cachePath, fallbackRepoUrl);
-        const commitHash = lockEntry?.commit ?? "unknown";
+        if (lockedCommit) {
+          this.logger.verbose(`Checking out locked commit: ${lockedCommit}`);
+          await this.gitRegistry.checkoutCommit(cachePath, lockedCommit);
+        }
+        const commitHash = lockedCommit ?? lockEntry?.commit ?? "unknown";
         await this.registryCache.set(repoUrl, effectiveVersion, commitHash);
       }
       const isRoot = subPath === "";
       const isMdPath = !isRoot && subPath.endsWith(".md");
       const resolvedFileName = isRoot ? "" : isMdPath ? subPath : subPath.endsWith(".prs") ? subPath : `${subPath}.prs`;
       const resolvedFullPath = isRoot ? "" : join8(cachePath, resolvedFileName);
+      if (!isRoot) {
+        const rel = relative4(resolve9(cachePath), resolve9(resolvedFullPath));
+        if (rel.startsWith("..") || resolve9(resolvedFullPath) === resolve9(cachePath)) {
+          errors.push(
+            new ResolveError(
+              `Path traversal detected: subpath '${subPath}' escapes repository cache boundary.`
+            )
+          );
+          this.resolving.delete(marker);
+          return { ast: null, sources: [marker], errors };
+        }
+      }
       let resolvedAST = null;
       if (!isRoot && existsSync9(resolvedFullPath) && isMdPath) {
         this.logger.debug(`Found .md file: ${resolvedFullPath}`);
@@ -25931,6 +26166,18 @@ var Resolver = class {
         );
       } else {
         const discoverDir = isRoot ? cachePath : join8(cachePath, subPath);
+        if (!isRoot) {
+          const dirRel = relative4(resolve9(cachePath), resolve9(discoverDir));
+          if (dirRel.startsWith("..")) {
+            errors.push(
+              new ResolveError(
+                `Path traversal detected: subpath '${subPath}' escapes repository cache boundary.`
+              )
+            );
+            this.resolving.delete(marker);
+            return { ast: null, sources: [marker], errors };
+          }
+        }
         if (!isRoot && !existsSync9(discoverDir)) {
           errors.push(
             new ResolveError(
@@ -25985,7 +26232,7 @@ var Resolver = class {
   async tryDirectoryScan(dirPath, sources, errors) {
     let stat4;
     try {
-      stat4 = await lstat3(dirPath);
+      stat4 = await lstat4(dirPath);
     } catch {
       return null;
     }
@@ -26038,7 +26285,7 @@ var Resolver = class {
         const subDir = join8(currentDir, entry.name);
         let subStat;
         try {
-          subStat = await lstat3(subDir);
+          subStat = await lstat4(subDir);
         } catch {
           continue;
         }
@@ -26093,6 +26340,41 @@ var Resolver = class {
   clearCache() {
     this.cache.clear();
   }
+  /**
+   * Verify integrity hashes for registry reference files.
+   * Reads each referenced file from the registry cache and compares its
+   * hash against the lockfile entry.
+   *
+   * @param lockfile - Lockfile with reference hashes
+   * @returns Array of errors for mismatched references
+   */
+  async verifyReferenceHashes(lockfile) {
+    if (!lockfile.references) return [];
+    const errors = [];
+    for (const [key, entry] of Object.entries(lockfile.references)) {
+      const parts = key.split("\0");
+      if (parts.length !== 3) continue;
+      const [repoUrl, relativePath, version] = parts;
+      try {
+        const cachePath = this.registryCache.getCachePath(repoUrl, version);
+        const fullPath = join8(cachePath, relativePath);
+        if (!existsSync9(fullPath)) continue;
+        const content = await readFile11(fullPath);
+        const actualHash = hashContent(content);
+        if (actualHash !== entry.hash) {
+          errors.push(
+            new ResolveError(
+              `Reference file hash mismatch: ${relativePath} has changed since last lock. Run \`prs lock --update\` to accept changes.`,
+              void 0,
+              "PS2023" /* LOCKFILE_INTEGRITY */
+            )
+          );
+        }
+      } catch {
+      }
+    }
+    return errors;
+  }
   /**
    * Get the file loader.
    */
@@ -26186,7 +26468,7 @@ var HttpRegistry = class {
    * Sleep for specified milliseconds.
    */
   sleep(ms) {
-    return new Promise((resolve22) => setTimeout(resolve22, ms));
+    return new Promise((resolve24) => setTimeout(resolve24, ms));
   }
   /**
    * Fetch with timeout.
@@ -26568,13 +26850,6 @@ function formatSkillValidationIssues(issues) {
 // packages/resolver/src/index.ts
 init_src();
 
-// packages/resolver/src/reference-hasher.ts
-import { createHash as createHash2 } from "crypto";
-function hashContent(content) {
-  const hex = createHash2("sha256").update(content).digest("hex");
-  return `sha256-${hex}`;
-}
-
 // packages/validator/src/validator.ts
 init_src();
 
@@ -26791,10 +27066,10 @@ function walkValue(value, loc, callback, exclude) {
       const typed = value;
       if (typed.type === "TextContent" && typeof typed.value === "string") {
         callback(typed.value, typed.loc ?? loc);
+        return;
       }
-    } else {
-      walkObjectProperties(value, loc, callback, exclude);
     }
+    walkObjectProperties(value, loc, callback, exclude);
   }
 }
 function offsetLocation(baseLoc, text, charIndex) {
@@ -27883,7 +28158,10 @@ function decodeRawHex(hex) {
     if (isNaN(byte)) return null;
     bytes.push(byte);
   }
-  const decoded = String.fromCharCode(...bytes);
+  let decoded = "";
+  for (const byte of bytes) {
+    decoded += String.fromCharCode(byte);
+  }
   if (/[\x00-\x08\x0E-\x1F]/.test(decoded)) {
     return null;
   }
@@ -29381,10 +29659,14 @@ function getComposedFrom(skill) {
   return raw.filter(isComposedFromEntry);
 }
 function extractRegistry(source) {
-  if (!source.startsWith("@")) return null;
-  const slash = source.indexOf("/");
-  if (slash === -1) return source;
-  return source.slice(0, slash);
+  if (source.startsWith("@")) {
+    const slash = source.indexOf("/");
+    if (slash === -1) return source;
+    return source.slice(0, slash);
+  }
+  const match = /\/(@[a-zA-Z_][a-zA-Z0-9_-]*)\//.exec(source);
+  if (match) return match[1] ?? null;
+  return null;
 }
 function matchesTargetPattern(composedFrom, targetPattern) {
   const registry2 = extractRegistry(targetPattern);
@@ -29646,6 +29928,17 @@ var Validator = class {
     }
     this.logger.debug(`Validator initialized with ${this.rules.length} rules`);
   }
+  /**
+   * Update validator configuration after construction.
+   * Allows the compiler to inject runtime data (registry references, lockfile, etc.)
+   * that becomes available only after resolution.
+   */
+  updateConfig(partial) {
+    this.config = { ...this.config, ...partial };
+    if (partial.disableRules) {
+      this.disabledRules = new Set(partial.disableRules);
+    }
+  }
   /**
    * Validate an AST.
    *
@@ -29776,7 +30069,7 @@ var SECURITY_STRICT_MULTILINGUAL = {
 };
 
 // packages/compiler/src/compiler.ts
-import { relative as relative3, isAbsolute as isAbsolute4 } from "path";
+import { relative as relative5, isAbsolute as isAbsolute4 } from "path";
 function generateHtmlMarker(source, target) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   return `<!-- PromptScript ${timestamp} | source: ${source} | target: ${target} - do not edit -->`;
@@ -29852,7 +30145,7 @@ var Compiler = class _Compiler {
       formatTime: 0,
       totalTime: 0
     };
-    const sourceLabel = isAbsolute4(entryPath) ? relative3(process.cwd(), entryPath) : entryPath;
+    const sourceLabel = isAbsolute4(entryPath) ? relative5(process.cwd(), entryPath) : entryPath;
     this.logger.verbose("=== Stage 1: Resolve ===");
     const startResolve = Date.now();
     let resolved;
@@ -29886,6 +30179,7 @@ var Compiler = class _Compiler {
         stats
       };
     }
+    const compileErrors = [];
     if (!this.options.ignoreHashes && this.options.resolver.lockfile?.references) {
       this.logger.verbose("=== Stage 1.5: Reference Integrity ===");
       const registryReferences = /* @__PURE__ */ new Set();
@@ -29902,17 +30196,29 @@ var Compiler = class _Compiler {
           }
         }
       }
-      if (this.options.validator) {
-        this.options.validator.registryReferences = registryReferences;
-        this.options.validator.lockfile = this.options.resolver.lockfile;
-        this.options.validator.ignoreHashes = this.options.ignoreHashes;
+      const hashErrors = await this.resolver.verifyReferenceHashes(this.options.resolver.lockfile);
+      for (const err of hashErrors) {
+        compileErrors.push(this.toCompileError(err));
       }
+      this.validator.updateConfig({
+        registryReferences,
+        lockfile: this.options.resolver.lockfile,
+        ignoreHashes: this.options.ignoreHashes
+      });
     } else if (this.options.ignoreHashes) {
       this.logger.verbose("--ignore-hashes is set: reference integrity verification is disabled");
       console.error("\u26A0 --ignore-hashes is set: reference integrity verification is disabled");
-      if (this.options.validator) {
-        this.options.validator.ignoreHashes = true;
-      }
+      this.validator.updateConfig({ ignoreHashes: true });
+    }
+    if (compileErrors.length > 0) {
+      stats.totalTime = Date.now() - startTotal;
+      return {
+        success: false,
+        outputs: /* @__PURE__ */ new Map(),
+        errors: compileErrors,
+        warnings: [],
+        stats
+      };
     }
     this.logger.verbose("=== Stage 2: Validate ===");
     const startValidate = Date.now();
@@ -30109,12 +30415,12 @@ var Compiler = class _Compiler {
    */
   async watch(entryPath, options = {}) {
     const { default: chokidar2 } = await import("chokidar");
-    const { dirname: dirname17, resolve: resolve22 } = await import("path");
-    const baseDir = dirname17(resolve22(entryPath));
+    const { dirname: dirname18, resolve: resolve24 } = await import("path");
+    const baseDir = dirname18(resolve24(entryPath));
     const includePatterns = options.include ?? ["**/*.prs"];
     const excludePatterns = options.exclude ?? ["**/node_modules/**"];
     const debounceMs = options.debounce ?? 300;
-    const watchPatterns = includePatterns.map((p) => resolve22(baseDir, p));
+    const watchPatterns = includePatterns.map((p) => resolve24(baseDir, p));
     let debounceTimer = null;
     let pendingChanges = [];
     const handleChange = async (changedFiles) => {
@@ -30289,7 +30595,7 @@ var Pager = class {
       }
       return;
     }
-    return new Promise((resolve22) => {
+    return new Promise((resolve24) => {
       const pagerCmd = getPagerCommand();
       const [cmd, ...args] = pagerCmd.split(" ");
       if (cmd === "less" && !args.includes("-R")) {
@@ -30297,7 +30603,7 @@ var Pager = class {
       }
       if (!cmd) {
         console.log(content);
-        resolve22();
+        resolve24();
         return;
       }
       const pager = spawn(cmd, args, {
@@ -30310,17 +30616,17 @@ var Pager = class {
       });
       pager.on("error", (_err) => {
         console.log(content);
-        resolve22();
+        resolve24();
       });
       pager.on("close", () => {
-        resolve22();
+        resolve24();
       });
       if (pager.stdin) {
         pager.stdin.write(content);
         pager.stdin.end();
       } else {
         console.log(content);
-        resolve22();
+        resolve24();
       }
     });
   }
@@ -30430,9 +30736,9 @@ var __dirname2 = dirname9(__filename2);
 async function loadBundledSkillContent(logger) {
   const skillRelPath = "skills/promptscript/SKILL.md";
   const candidates = [
-    resolve8(__dirname2, skillRelPath),
+    resolve10(__dirname2, skillRelPath),
     // bundled: dist/packages/cli/skills/...
-    resolve8(__dirname2, "..", "..", skillRelPath)
+    resolve10(__dirname2, "..", "..", skillRelPath)
     // dev: packages/cli/skills/...
   ];
   for (const candidate of candidates) {
@@ -30453,7 +30759,7 @@ async function loadBundledSkillContent(logger) {
 }
 function findConfigInDir(dir) {
   for (const file of CONFIG_FILES) {
-    const fullPath = resolve8(dir, file);
+    const fullPath = resolve10(dir, file);
     if (existsSync12(fullPath)) {
       return fullPath;
     }
@@ -30510,7 +30816,7 @@ function getBuildProfile(config, buildName) {
 }
 function resolveOutputBase(projectRoot, output) {
   if (!output) return projectRoot;
-  return isAbsolute5(output) ? output : resolve8(projectRoot, output);
+  return isAbsolute5(output) ? output : resolve10(projectRoot, output);
 }
 async function isPromptScriptGenerated2(filePath) {
   try {
@@ -30576,7 +30882,7 @@ async function writeOutputs(outputs, options, _config, services) {
     }
   }
   for (const output of outputs.values()) {
-    const outputPath = options.output ? resolve8(options.output, output.path) : resolve8(output.path);
+    const outputPath = options.output ? resolve10(options.output, output.path) : resolve10(output.path);
     const fileExists3 = existsSync12(outputPath);
     if (options.dryRun) {
       if (fileExists3) {
@@ -30710,14 +31016,21 @@ async function compileCommand(options, services = createDefaultServices()) {
   const spinner = createSpinner("Loading configuration...").start();
   const logger = createCliLogger();
   try {
-    const projectRoot = options.cwd ? resolve8(options.cwd) : process.cwd();
+    const projectRoot = options.cwd ? resolve10(options.cwd) : process.cwd();
     logger.verbose("Loading configuration...");
     const configPath = options.config ? options.config : options.cwd ? findConfigInDir(projectRoot) : void 0;
-    const config = await loadConfig(configPath);
+    const config = await loadEffectiveConfig(configPath);
     const buildProfile = getBuildProfile(config, options.build);
     const selectedTarget = options.target ?? options.format;
     const targetEntries = buildProfile?.targets ?? config.targets;
-    const targets = selectedTarget ? [{ name: selectedTarget }] : parseTargets(targetEntries);
+    const parsedTargets = parseTargets(targetEntries);
+    let targets;
+    if (selectedTarget) {
+      const matched = parsedTargets.find((t) => t.name === selectedTarget);
+      targets = matched ? [matched] : [{ name: selectedTarget }];
+    } else {
+      targets = parsedTargets;
+    }
     const conflicts = detectOutputConflicts(targets);
     if (conflicts.size > 0) {
       const lines = [...conflicts.entries()].map(
@@ -30750,7 +31063,7 @@ Disable one of the conflicting targets or assign a custom output path.`
       }
     }
     let lockfile;
-    const lockfilePath = resolve8(projectRoot, "promptscript.lock");
+    const lockfilePath = resolve10(projectRoot, "promptscript.lock");
     try {
       const lockfileContent = await readFile12(lockfilePath, "utf-8");
       const parsed = parseYaml5(lockfileContent, { maxAliasCount: 100 });
@@ -30770,7 +31083,7 @@ Disable one of the conflicting targets or assign a custom output path.`
     if (config.includePromptScriptSkill !== false) {
       skillContent = await loadBundledSkillContent(logger);
     }
-    const localPath = resolve8(projectRoot, ".promptscript");
+    const localPath = resolve10(projectRoot, ".promptscript");
     const compiler = new Compiler({
       resolver: {
         registryPath,
@@ -30790,7 +31103,7 @@ Disable one of the conflicting targets or assign a custom output path.`
       ignoreHashes: options.ignoreHashes
     });
     const entry = buildProfile?.entry ?? config.input?.entry;
-    const entryPath = entry ? resolve8(projectRoot, entry) : resolve8(localPath, "project.prs");
+    const entryPath = entry ? resolve10(projectRoot, entry) : resolve10(localPath, "project.prs");
     if (!existsSync12(entryPath)) {
       spinner.fail("Entry file not found");
       ConsoleOutput.error(`File not found: ${entryPath}`);
@@ -30830,7 +31143,7 @@ Disable one of the conflicting targets or assign a custom output path.`
       ConsoleOutput.newline();
       ConsoleOutput.info("Watching for changes... (Ctrl+C to stop)");
       watchForChanges(
-        resolve8(projectRoot, ".promptscript"),
+        resolve10(projectRoot, ".promptscript"),
         () => compileCommand({ ...options, watch: false }, services)
       );
     }
@@ -30881,7 +31194,7 @@ function watchForChanges(dir, callback) {
 }
 
 // packages/cli/src/commands/validate.ts
-import { resolve as resolve9, join as join12 } from "path";
+import { resolve as resolve11, join as join12 } from "path";
 import { existsSync as existsSync13, readFileSync as readFileSync4, writeFileSync, readdirSync } from "fs";
 init_console();
 init_src();
@@ -31031,7 +31344,7 @@ async function validateCommand(options) {
       formatters: []
       // No formatters needed for validation only
     });
-    const entryPath = resolve9("./.promptscript/project.prs");
+    const entryPath = resolve11("./.promptscript/project.prs");
     if (!existsSync13(entryPath)) {
       handleEntryNotFound(entryPath, isJsonFormat, spinner);
       return;
@@ -31115,7 +31428,7 @@ ${fixedCount} file(s) fixed.`);
 // packages/cli/src/commands/pull.ts
 import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
 import { existsSync as existsSync14 } from "fs";
-import { resolve as resolve10, dirname as dirname10 } from "path";
+import { resolve as resolve12, dirname as dirname10 } from "path";
 init_console();
 async function pullCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
@@ -31140,7 +31453,7 @@ async function pullCommand(options) {
     }
     spinner.text = `Fetching ${inheritPath}...`;
     const content = await registry2.fetch(inheritPath);
-    const destPath = resolve10("./.promptscript/.inherited", inheritPath);
+    const destPath = resolve12("./.promptscript/.inherited", inheritPath);
     if (existsSync14(destPath) && !options.force && !options.dryRun) {
       spinner.warn("File already exists (use --force to overwrite)");
       ConsoleOutput.muted(destPath);
@@ -31202,7 +31515,7 @@ async function createRegistry(config, options, spinner) {
   if (!existsSync14(registryPath)) {
     throw new Error(`Local registry path not found: ${registryPath}`);
   }
-  return createFileSystemRegistry(resolve10(registryPath));
+  return createFileSystemRegistry(resolve12(registryPath));
 }
 function parseInheritPath(inheritPath) {
   const versionIndex = inheritPath.lastIndexOf("@");
@@ -31249,7 +31562,7 @@ function handlePullError(error, spinner) {
 }
 
 // packages/cli/src/commands/diff.ts
-import { resolve as resolve11 } from "path";
+import { resolve as resolve13 } from "path";
 import { readFile as readFile13 } from "fs/promises";
 import { existsSync as existsSync15 } from "fs";
 init_console();
@@ -31286,7 +31599,7 @@ function printNewFilePreview(content, showFull, pager) {
   }
 }
 async function compareOutput(_name, output, _config, showFull, pager) {
-  const outputPath = resolve11(output.path);
+  const outputPath = resolve13(output.path);
   const newContent = output.content;
   if (!existsSync15(outputPath)) {
     pager.write(chalk2.green(`+ ${outputPath} (new file)`));
@@ -31328,7 +31641,7 @@ async function diffCommand(options) {
       formatters: targets,
       customConventions: config.customConventions
     });
-    const entryPath = resolve11("./.promptscript/project.prs");
+    const entryPath = resolve13("./.promptscript/project.prs");
     if (!existsSync15(entryPath)) {
       spinner.fail("Entry file not found");
       ConsoleOutput.error(`File not found: ${entryPath}`);
@@ -31398,7 +31711,7 @@ function printSimpleDiff(existingLines, newLines, showFull, pager) {
 
 // packages/cli/src/commands/check.ts
 import { existsSync as existsSync16 } from "fs";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve14 } from "path";
 init_console();
 async function checkCommand(_options) {
   const spinner = createSpinner("Checking project health...").start();
@@ -31476,7 +31789,7 @@ async function checkCommand(_options) {
       hasErrors = true;
     }
     if (config.registry?.path) {
-      const registryPath = resolve12(config.registry.path);
+      const registryPath = resolve14(config.registry.path);
       if (existsSync16(registryPath)) {
         results.push({
           name: "Registry path",
@@ -31840,8 +32153,32 @@ var SEED_SECURITY = `@meta {
 `;
 async function scaffoldRegistry(options, services) {
   const { fs: fs4 } = services;
-  const { directory, name, description, namespaces, seed } = options;
+  const { directory, name, description, namespaces, seed, force } = options;
   const createdFiles = [];
+  const existingManifestPath = join14(directory, "registry-manifest.yaml");
+  if (fs4.existsSync(existingManifestPath) && !force) {
+    throw new Error(
+      `Directory already contains a registry-manifest.yaml. Use --force to overwrite.`
+    );
+  }
+  if (!force) {
+    let entries;
+    try {
+      entries = await fs4.readdir(directory);
+    } catch (err) {
+      const nodeErr = err;
+      if (nodeErr.code !== "ENOENT") {
+        throw err;
+      }
+      entries = [];
+    }
+    const visibleEntries = entries.filter((e) => !e.startsWith("."));
+    if (visibleEntries.length > 0) {
+      throw new Error(
+        `Directory "${directory}" is not empty. Use --force to overwrite existing files.`
+      );
+    }
+  }
   await fs4.mkdir(directory, { recursive: true });
   const manifest = generateManifest(name, description, namespaces, seed);
   const manifestPath = join14(directory, "registry-manifest.yaml");
@@ -31981,7 +32318,7 @@ Then reference configs with \`@inherit\` or \`@use\`:
 }
 
 // packages/cli/src/utils/resolve-target-directory.ts
-import { join as join15, resolve as resolve13 } from "path";
+import { join as join15, resolve as resolve15 } from "path";
 
 // packages/cli/src/utils/slugify.ts
 function slugify(name) {
@@ -31992,7 +32329,7 @@ function slugify(name) {
 async function resolveTargetDirectory(options, services) {
   const { cwd, directoryArg, registryName, nonInteractive } = options;
   if (directoryArg) {
-    return resolve13(directoryArg);
+    return resolve15(directoryArg);
   }
   const empty = await isDirectoryEmpty(cwd, services.fs);
   if (empty && nonInteractive) {
@@ -32068,7 +32405,7 @@ async function registryInitCommand(directory, options, services = createDefaultS
     );
     const spinner = createSpinner("Creating registry...").start();
     const createdFiles = await scaffoldRegistry(
-      { directory: targetDir, name, description, namespaces, seed },
+      { directory: targetDir, name, description, namespaces, seed, force: options.force },
       services
     );
     spinner.succeed("Registry created");
@@ -32099,7 +32436,7 @@ async function registryInitCommand(directory, options, services = createDefaultS
 // packages/cli/src/commands/registry/validate.ts
 init_services();
 init_console();
-import { resolve as resolve14 } from "path";
+import { resolve as resolve16 } from "path";
 
 // packages/cli/src/utils/registry-validator.ts
 import { join as join16 } from "path";
@@ -32299,7 +32636,7 @@ function detectCircularDependencies(catalog) {
 
 // packages/cli/src/commands/registry/validate.ts
 async function registryValidateCommand(path, options, services = createDefaultServices()) {
-  const registryPath = resolve14(path ?? ".");
+  const registryPath = resolve16(path ?? ".");
   const spinner = createSpinner("Validating registry...").start();
   try {
     const result = await validateRegistry(registryPath, services);
@@ -32351,10 +32688,10 @@ async function registryValidateCommand(path, options, services = createDefaultSe
 // packages/cli/src/commands/registry/publish.ts
 init_services();
 init_console();
-import { resolve as resolve15, join as join17 } from "path";
+import { resolve as resolve17, join as join17 } from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 async function registryPublishCommand(path, options, services = createDefaultServices()) {
-  const registryPath = resolve15(path ?? ".");
+  const registryPath = resolve17(path ?? ".");
   try {
     if (!options.force) {
       const spinner2 = createSpinner("Validating registry...").start();
@@ -32579,7 +32916,7 @@ async function addToProjectConfig(alias, url) {
 
 // packages/cli/src/commands/registry/index.ts
 function registerRegistryCommands(registry2) {
-  registry2.command("init [directory]").description("Create a new PromptScript registry").option("-n, --name <name>", "Registry name").option("-d, --description <desc>", "Registry description").option("--namespaces <ns...>", "Namespace names (e.g., @core @stacks)").option("-y, --yes", "Non-interactive mode with defaults").option("-o, --output <dir>", "Output directory").option("--no-seed", "Skip seed configurations").action((directory, opts) => registryInitCommand(directory, opts));
+  registry2.command("init [directory]").description("Create a new PromptScript registry").option("-n, --name <name>", "Registry name").option("-d, --description <desc>", "Registry description").option("--namespaces <ns...>", "Namespace names (e.g., @core @stacks)").option("-y, --yes", "Non-interactive mode with defaults").option("-o, --output <dir>", "Output directory").option("--no-seed", "Skip seed configurations").option("-f, --force", "Force overwrite existing files").action((directory, opts) => registryInitCommand(directory, opts));
   registry2.command("validate [path]").description("Validate registry structure and manifest").option("--strict", "Treat warnings as errors").option("--format <format>", "Output format (text, json)", "text").action((path, opts) => registryValidateCommand(path, opts));
   registry2.command("publish [path]").description("Publish registry to remote").option("--dry-run", "Preview what would be published").option("-f, --force", "Skip validation").option("-m, --message <msg>", "Git commit message").option("--tag <tag>", "Git tag for release").action((path, opts) => registryPublishCommand(path, opts));
   registry2.command("list").description("Show merged registry alias mappings from all config levels").action(() => registryListCommand());
@@ -32589,7 +32926,7 @@ function registerRegistryCommands(registry2) {
 // packages/cli/src/commands/lock.ts
 import { writeFile as writeFile8, readFile as readFile18 } from "fs/promises";
 import { existsSync as existsSync19 } from "fs";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve18 } from "path";
 import { parse as parseYaml9, stringify as stringifyYaml2 } from "yaml";
 init_console();
 init_src();
@@ -32662,8 +32999,8 @@ async function lockCommand(options) {
     const aliases = config.registries ?? {};
     const aliasEntries = Object.entries(aliases);
     const projectRoot = process.cwd();
-    const localPath = resolve16(projectRoot, ".promptscript");
-    const entryPath = config.input?.entry ? resolve16(projectRoot, config.input.entry) : resolve16(localPath, "project.prs");
+    const localPath = resolve18(projectRoot, ".promptscript");
+    const entryPath = config.input?.entry ? resolve18(projectRoot, config.input.entry) : resolve18(localPath, "project.prs");
     const scannedImports = await collectRemoteImports(entryPath, {
       localPath,
       registries: config.registries
@@ -32790,10 +33127,12 @@ async function updateCommand(packageArg, options) {
     const dependencies = { ...existing.dependencies };
     for (const repoUrl of toUpdate) {
       const before = existing.dependencies[repoUrl]?.version ?? "(none)";
+      const existingDep = existing.dependencies[repoUrl];
+      const validation = await validateRemoteAccess(repoUrl);
       const updated = {
         version: "latest",
-        commit: "0000000000000000000000000000000000000000",
-        integrity: "sha256-pending"
+        commit: validation.headCommit ?? existingDep?.commit ?? "0000000000000000000000000000000000000000",
+        integrity: existingDep?.integrity ?? "sha256-pending"
       };
       dependencies[repoUrl] = updated;
       updates.push({ repoUrl, before, after: updated.version });
@@ -32831,7 +33170,7 @@ init_console();
 init_src();
 import { readFile as readFile20, writeFile as writeFile10, mkdir as mkdir8, readdir as readdir5 } from "fs/promises";
 import { existsSync as existsSync21 } from "fs";
-import { join as join18, resolve as resolve17 } from "path";
+import { join as join18, resolve as resolve19 } from "path";
 import { homedir as homedir4 } from "os";
 import { parse as parseYaml11 } from "yaml";
 var VENDOR_DIR = ".promptscript/vendor";
@@ -32859,7 +33198,7 @@ async function vendorSyncCommand(options) {
         continue;
       }
       if (!options.dryRun) {
-        const vendorTarget = resolve17(VENDOR_DIR, repoUrl.replace(/[/:]/g, "_"));
+        const vendorTarget = resolve19(VENDOR_DIR, repoUrl.replace(/[/:]/g, "_"));
         await mkdir8(vendorTarget, { recursive: true });
         await copyDirectory(cacheDir, vendorTarget);
       }
@@ -32913,7 +33252,7 @@ async function vendorCheckCommand(_options) {
     }
     const issues = [];
     for (const [repoUrl] of deps) {
-      const vendorTarget = resolve17(VENDOR_DIR, repoUrl.replace(/[/:]/g, "_"));
+      const vendorTarget = resolve19(VENDOR_DIR, repoUrl.replace(/[/:]/g, "_"));
       if (!existsSync21(vendorTarget)) {
         issues.push({ repoUrl, issue: "missing from vendor directory" });
       }
@@ -33050,7 +33389,7 @@ async function resolveCommand(importPath, _options) {
 
 // packages/cli/src/commands/inspect.ts
 import { existsSync as existsSync23 } from "fs";
-import { resolve as resolve18, basename as basename13 } from "path";
+import { resolve as resolve20, basename as basename13 } from "path";
 init_console();
 async function inspectCommand(skillName, options) {
   const isJson = options.format === "json";
@@ -33063,7 +33402,7 @@ async function inspectCommand(skillName, options) {
       localPath: "./.promptscript",
       registries: config.registries
     });
-    const entryPath = resolve18("./.promptscript/project.prs");
+    const entryPath = resolve20("./.promptscript/project.prs");
     if (!existsSync23(entryPath)) {
       spinner.stop();
       ConsoleOutput.error(`Entry file not found: ${entryPath}`);
@@ -33244,7 +33583,7 @@ init_console();
 // packages/cli/src/commands/import.ts
 init_src3();
 init_console();
-import { resolve as resolve19, join as join20, basename as basename14 } from "path";
+import { resolve as resolve21, join as join20, basename as basename14 } from "path";
 import { writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync24 } from "fs";
 import { stat as stat2, readdir as readdir6, readFile as readFile21, writeFile as writeFile11, mkdir as mkdir9 } from "fs/promises";
 function parseInstructionFrontmatter(content) {
@@ -33299,7 +33638,7 @@ async function importDirectory(dirPath) {
   return lines.join("\n");
 }
 async function importCommand(file, options) {
-  const filepath = resolve19(file);
+  const filepath = resolve21(file);
   const inputStat = await stat2(filepath).catch(() => null);
   if (inputStat?.isDirectory()) {
     const prsContent = await importDirectory(filepath);
@@ -33331,11 +33670,11 @@ async function importCommand(file, options) {
       console.log(result.prsContent);
       return;
     }
-    const outputDir = resolve19(options.output ?? ".promptscript");
+    const outputDir = resolve21(options.output ?? ".promptscript");
     if (!existsSync24(outputDir)) {
       mkdirSync(outputDir, { recursive: true });
     }
-    const outputPath = resolve19(outputDir, "imported.prs");
+    const outputPath = resolve21(outputDir, "imported.prs");
     writeFileSync2(outputPath, result.prsContent, "utf-8");
     ConsoleOutput.success(`Written to ${outputPath}`);
     if (options.validate) {
@@ -33570,7 +33909,7 @@ init_hooks();
 
 // packages/cli/src/commands/skills.ts
 import { writeFile as writeFile12, readFile as readFile23, readdir as readdir7, mkdtemp, rm } from "fs/promises";
-import { resolve as resolve20, join as join22, basename as basename15, dirname as dirname13 } from "path";
+import { resolve as resolve22, join as join22, basename as basename15, dirname as dirname13 } from "path";
 import { existsSync as existsSync26 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { parse as parseYaml12, stringify as stringifyYaml4 } from "yaml";
@@ -33690,7 +34029,7 @@ function validateRemoteSource(source) {
 }
 async function resolveEntryFile(fileFlag) {
   if (fileFlag) {
-    const resolved = resolve20(fileFlag);
+    const resolved = resolve22(fileFlag);
     if (!existsSync26(resolved)) {
       throw new Error(`File not found: ${resolved}`);
     }
@@ -33701,7 +34040,7 @@ async function resolveEntryFile(fileFlag) {
     try {
       const config = await loadConfig();
       if (config.input?.entry) {
-        const entryPath = resolve20(config.input.entry);
+        const entryPath = resolve22(config.input.entry);
         if (existsSync26(entryPath)) {
           return entryPath;
         }
@@ -33709,16 +34048,16 @@ async function resolveEntryFile(fileFlag) {
     } catch {
     }
   }
-  const promptscriptDir = resolve20(".promptscript");
+  const promptscriptDir = resolve22(".promptscript");
   if (existsSync26(promptscriptDir)) {
     const entries = await readdir7(promptscriptDir);
     const prsFiles = entries.filter((f) => f.endsWith(".prs"));
     if (prsFiles.length === 1) {
-      return resolve20(promptscriptDir, prsFiles[0]);
+      return resolve22(promptscriptDir, prsFiles[0]);
     }
     if (prsFiles.length > 1) {
       if (prsFiles.includes("project.prs")) {
-        return resolve20(promptscriptDir, "project.prs");
+        return resolve22(promptscriptDir, "project.prs");
       }
       throw new Error(
         `Multiple .prs files found in .promptscript/. Use --file to specify which one.`
@@ -34069,7 +34408,7 @@ async function skillsUpdateCommand(name, options) {
 
 // packages/cli/src/cli.ts
 var __filename4 = fileURLToPath4(import.meta.url);
-var __dirname4 = dirname16(__filename4);
+var __dirname4 = dirname17(__filename4);
 var program = new Command();
 program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname3, "./package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", async (thisCommand, actionCommand) => {
   const opts = thisCommand.opts();
@@ -34137,7 +34476,9 @@ registerRegistryCommands(registry);
 function run(args = process.argv) {
   program.parse(args);
 }
-run();
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  run();
+}
 
 // packages/cli/src/index.ts
 init_init();