@promptscript/cli 1.0.0-alpha.5 → 1.0.0-alpha.7

package/index.js

@@ -1,7 +1,7 @@
 // packages/cli/src/cli.ts
 import { Command } from "commander";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname9 } from "path";
 
 // packages/core/src/types/constants.ts
 var BLOCK_TYPES = [
@@ -306,7 +306,7 @@ var noopLogger = {
 
 // packages/cli/src/commands/init.ts
 import { fileURLToPath } from "url";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 
 // packages/cli/src/services.ts
 import { writeFile, mkdir, readFile, readdir } from "fs/promises";
@@ -405,6 +405,13 @@ var ConsoleOutput = {
     if (isQuiet()) return;
     console.log(chalk.yellow(`  \u2298 ${message}`));
   },
+  /**
+   * Print an unchanged file message.
+   */
+  unchanged(message) {
+    if (isQuiet()) return;
+    console.log(chalk.gray(`  \u25CB ${message}`));
+  },
   /**
    * Print an info message.
    */
@@ -859,9 +866,910 @@ async function resolvePrettierOptions(config, basePath = process.cwd()) {
   return result;
 }
 
+// packages/cli/src/templates/migrate-skill.ts
+var MIGRATE_SKILL_CLAUDE = `---
+name: 'migrate-to-promptscript'
+description: 'Migrate existing AI instruction files to PromptScript format'
+allowed-tools:
+  - Read
+  - Write
+  - Glob
+  - Grep
+  - Bash
+user-invocable: true
+---
+
+# Migrate to PromptScript
+
+## Overview
+
+This skill guides you through migrating existing AI instruction files
+to PromptScript format, creating a unified source of truth for all
+AI coding assistants.
+
+## Step 1: Discovery
+
+Search for existing instruction files using these patterns:
+
+Claude Code:
+
+- CLAUDE.md, claude.md, CLAUDE.local.md
+
+Cursor:
+
+- .cursorrules
+- .cursor/rules/\\*.md
+- .cursor/rules/\\*.mdc
+
+GitHub Copilot:
+
+- .github/copilot-instructions.md
+- .github/instructions/\\*.md
+
+Other:
+
+- AGENTS.md
+- AI_INSTRUCTIONS.md
+- AI.md
+- .ai/instructions.md
+
+Use Glob tool to find these files.
+
+## Step 2: Read and Analyze
+
+For each discovered file:
+
+1. Read the full content using the Read tool
+2. Identify sections by headers (##, ###) and patterns
+3. Classify content type using the mapping table below
+4. Note any tool-specific content that may need special handling
+
+## Step 3: Content Mapping
+
+Map source content to PromptScript blocks:
+
+| Source Pattern                       | PromptScript Block |
+| ------------------------------------ | ------------------ |
+| You are, persona, identity, role     | @identity          |
+| Tech stack, languages, frameworks    | @context           |
+| Coding standards, conventions, rules | @standards         |
+| Don't, Never, restrictions           | @restrictions      |
+| Commands, shortcuts                  | @shortcuts         |
+| API docs, references, knowledge base | @knowledge         |
+| Parameters, config values            | @params            |
+| File patterns, globs, applyTo        | @guards            |
+| Skills, capabilities                 | @skills            |
+| Agents, subagents                    | @agents            |
+| Local-only settings                  | @local             |
+
+## Step 4: Generate PromptScript
+
+### Required: @meta block
+
+Every PromptScript file needs metadata with id and syntax fields.
+
+### Identity (persona)
+
+Convert persona descriptions to @identity block with triple-quote string.
+
+### Context (project info)
+
+Convert tech stack to @context block with structured properties
+like project, languages, frameworks.
+
+### Standards (conventions)
+
+Convert coding standards to @standards block organized by category:
+code, naming, commits, etc.
+
+### Restrictions (don'ts)
+
+Convert restrictions to @restrictions block using dash prefix for each item.
+
+### Shortcuts (commands)
+
+Convert custom commands to @shortcuts block. Simple shortcuts use
+key-value format. Complex shortcuts use object format with
+prompt, description, and content fields.
+
+### Knowledge (references)
+
+Convert API docs and reference material to @knowledge block
+using triple-quote string for rich content.
+
+### Guards (file patterns)
+
+Convert file-specific rules to @guards block with globs array
+specifying file patterns.
+
+### Params (configuration)
+
+Convert configuration parameters to @params block with type annotations:
+range(), enum(), boolean.
+
+### Skills (capabilities)
+
+Convert skill definitions to @skills block with description,
+trigger, and content fields.
+
+### Agents (subagents)
+
+Convert agent definitions to @agents block with description,
+tools, model, and content fields.
+
+## Step 5: File Organization
+
+Simple Projects - single file structure:
+
+- .promptscript/project.prs
+- promptscript.yaml
+
+Complex Projects - modular file structure:
+
+- .promptscript/project.prs (main with @use imports)
+- .promptscript/context.prs
+- .promptscript/standards.prs
+- .promptscript/restrictions.prs
+- .promptscript/commands.prs
+- promptscript.yaml
+
+## Step 6: Configuration
+
+Create promptscript.yaml with:
+
+- version: '1'
+- project.id
+- input.entry pointing to main .prs file
+- targets for github, claude, cursor
+
+## Step 7: Validation
+
+After generating PromptScript files:
+
+1. Validate syntax: prs validate
+2. Test compilation: prs compile --dry-run
+3. Compare output with original files
+4. Iterate if content is missing or incorrect
+
+## Common Patterns
+
+### Merging Multiple Sources
+
+When instructions exist in multiple files:
+
+1. Identity: Take from most detailed source
+2. Standards: Merge all, deduplicate
+3. Restrictions: Combine all (union)
+4. Commands: Merge, resolve conflicts
+
+### Tool-Specific Content
+
+Handle tool-specific content:
+
+- GitHub prompts: Use @shortcuts with prompt: true
+- Claude agents: Use @agents block
+- Cursor rules: Map to @standards
+- Local content: Use @local block
+
+### Preserving Formatting
+
+Use triple-quote multiline strings for:
+
+- Rich markdown content
+- Code examples
+- Complex instructions
+
+## Syntax Rules
+
+Quick reference for PromptScript syntax:
+
+- Strings: quoted or identifier
+- Multi-line: triple quotes
+- Arrays: [item1, item2] or - item prefix
+- Objects: { key: value }
+- Comments: # comment
+- Required @meta fields: id, syntax
+
+## Quality Checklist
+
+Before completing migration:
+
+- @meta block has id and syntax
+- Identity is clear and specific
+- Standards are organized by category
+- Restrictions use dash prefix (-)
+- Shortcuts work in target tools
+- prs validate passes
+- prs compile produces correct output
+- No duplicate content across blocks
+
+## Troubleshooting
+
+### Missing @meta Error
+Add required metadata block at the start.
+
+### Multiline String in Object Error
+Assign multiline strings to named keys, don't leave them loose
+inside objects.
+
+### Content Not Appearing in Output
+Check block names match expected patterns and
+verify syntax with prs validate --verbose.
+`;
+var MIGRATE_SKILL_CURSOR = `# Migrate to PromptScript
+
+Use this command to migrate existing AI instruction files to PromptScript format.
+
+## Step 1: Discovery
+
+Search for existing instruction files:
+
+- CLAUDE.md, claude.md, CLAUDE.local.md
+- .cursorrules, .cursor/rules/*.mdc
+- .github/copilot-instructions.md
+- AGENTS.md, AI_INSTRUCTIONS.md
+
+## Step 2: Content Mapping
+
+Map source content to PromptScript blocks:
+
+| Source Pattern                       | PromptScript Block |
+| ------------------------------------ | ------------------ |
+| You are, persona, identity, role     | @identity          |
+| Tech stack, languages, frameworks    | @context           |
+| Coding standards, conventions, rules | @standards         |
+| Don't, Never, restrictions           | @restrictions      |
+| Commands, shortcuts                  | @shortcuts         |
+| API docs, references                 | @knowledge         |
+
+## Step 3: Generate PromptScript
+
+Create \`.promptscript/project.prs\` with:
+
+1. **@meta** block with id and syntax fields (required)
+2. **@identity** for persona/role descriptions
+3. **@context** for tech stack info
+4. **@standards** organized by category
+5. **@restrictions** with dash prefix for each item
+6. **@shortcuts** for commands
+
+## Step 4: Validation
+
+After generating:
+
+1. Run \`prs validate\`
+2. Run \`prs compile --dry-run\`
+3. Compare output with original files
+
+## Syntax Quick Reference
+
+- Strings: quoted or identifier
+- Multi-line: triple quotes (\`"""\`)
+- Arrays: \`[item1, item2]\`
+- Objects: \`{ key: value }\`
+- Comments: \`# comment\`
+
+## Quality Checklist
+
+- @meta block has id and syntax
+- Standards organized by category
+- Restrictions use dash prefix (-)
+- prs validate passes
+`;
+var MIGRATE_SKILL_ANTIGRAVITY = `# Migrate to PromptScript
+
+This rule provides guidance for migrating existing AI instruction files to PromptScript format.
+
+## Overview
+
+PromptScript creates a unified source of truth for all AI coding assistants,
+compiling to native formats for Claude, GitHub Copilot, Cursor, and Antigravity.
+
+## Step 1: Discovery
+
+Search for existing instruction files:
+
+- CLAUDE.md, claude.md, CLAUDE.local.md
+- .cursorrules, .cursor/rules/*.mdc
+- .github/copilot-instructions.md
+- .agent/rules/*.md
+- AGENTS.md, AI_INSTRUCTIONS.md
+
+## Step 2: Content Mapping
+
+Map source content to PromptScript blocks:
+
+| Source Pattern                       | PromptScript Block |
+| ------------------------------------ | ------------------ |
+| You are, persona, identity, role     | @identity          |
+| Tech stack, languages, frameworks    | @context           |
+| Coding standards, conventions, rules | @standards         |
+| Don't, Never, restrictions           | @restrictions      |
+| Commands, shortcuts                  | @shortcuts         |
+| API docs, references                 | @knowledge         |
+
+## Step 3: Generate PromptScript
+
+Create \`.promptscript/project.prs\` with required blocks:
+
+1. **@meta** - id and syntax fields (required)
+2. **@identity** - persona/role descriptions
+3. **@context** - tech stack info
+4. **@standards** - coding rules organized by category
+5. **@restrictions** - things to avoid (dash prefix)
+6. **@shortcuts** - commands
+
+## Step 4: Validation
+
+After generating PromptScript files:
+
+1. Run \`prs validate\` to check syntax
+2. Run \`prs compile --dry-run\` to preview output
+3. Compare compiled output with original files
+
+## Syntax Reference
+
+- Strings: quoted or identifier
+- Multi-line: triple quotes
+- Arrays: [item1, item2]
+- Objects: { key: value }
+- Comments: # comment
+`;
+var MIGRATE_SKILL_GITHUB = `---
+name: 'migrate-to-promptscript'
+description: 'Migrate existing AI instruction files to PromptScript format'
+allowed-tools:
+  - read
+  - write
+  - glob
+  - grep
+  - execute
+user-invocable: true
+---
+
+# Migrate to PromptScript
+
+## Overview
+
+This skill guides you through migrating existing AI instruction files
+to PromptScript format, creating a unified source of truth for all
+AI coding assistants.
+
+## Step 1: Discovery
+
+Search for existing instruction files using these patterns:
+
+Claude Code:
+
+- CLAUDE.md, claude.md, CLAUDE.local.md
+
+Cursor:
+
+- .cursorrules
+- .cursor/rules/\\*.md
+- .cursor/rules/\\*.mdc
+
+GitHub Copilot:
+
+- .github/copilot-instructions.md
+- .github/instructions/\\*.md
+
+Other:
+
+- AGENTS.md
+- AI_INSTRUCTIONS.md
+- AI.md
+- .ai/instructions.md
+
+## Step 2: Read and Analyze
+
+For each discovered file:
+
+1. Read the full content
+2. Identify sections by headers (##, ###) and patterns
+3. Classify content type using the mapping table below
+4. Note any tool-specific content that may need special handling
+
+## Step 3: Content Mapping
+
+Map source content to PromptScript blocks:
+
+| Source Pattern                       | PromptScript Block |
+| ------------------------------------ | ------------------ |
+| You are, persona, identity, role     | @identity          |
+| Tech stack, languages, frameworks    | @context           |
+| Coding standards, conventions, rules | @standards         |
+| Don't, Never, restrictions           | @restrictions      |
+| Commands, shortcuts                  | @shortcuts         |
+| API docs, references, knowledge base | @knowledge         |
+| Parameters, config values            | @params            |
+| File patterns, globs, applyTo        | @guards            |
+| Skills, capabilities                 | @skills            |
+| Agents, subagents                    | @agents            |
+| Local-only settings                  | @local             |
+
+## Step 4: Generate PromptScript
+
+### Required: @meta block
+
+Every PromptScript file needs metadata with id and syntax fields.
+
+### Identity (persona)
+
+Convert persona descriptions to @identity block with triple-quote string.
+
+### Context (project info)
+
+Convert tech stack to @context block with structured properties
+like project, languages, frameworks.
+
+### Standards (conventions)
+
+Convert coding standards to @standards block organized by category:
+code, naming, commits, etc.
+
+### Restrictions (don'ts)
+
+Convert restrictions to @restrictions block using dash prefix for each item.
+
+### Shortcuts (commands)
+
+Convert custom commands to @shortcuts block. Simple shortcuts use
+key-value format. Complex shortcuts use object format with
+prompt, description, and content fields.
+
+## Step 5: File Organization
+
+Simple Projects - single file structure:
+
+- .promptscript/project.prs
+- promptscript.yaml
+
+Complex Projects - modular file structure:
+
+- .promptscript/project.prs (main with @use imports)
+- .promptscript/context.prs
+- .promptscript/standards.prs
+- .promptscript/restrictions.prs
+- .promptscript/commands.prs
+- promptscript.yaml
+
+## Step 6: Configuration
+
+Create promptscript.yaml with:
+
+- version: '1'
+- project.id
+- input.entry pointing to main .prs file
+- targets for github, claude, cursor
+
+## Step 7: Validation
+
+After generating PromptScript files:
+
+1. Validate syntax: prs validate
+2. Test compilation: prs compile --dry-run
+3. Compare output with original files
+4. Iterate if content is missing or incorrect
+
+## Quality Checklist
+
+Before completing migration:
+
+- @meta block has id and syntax
+- Identity is clear and specific
+- Standards are organized by category
+- Restrictions use dash prefix (-)
+- Shortcuts work in target tools
+- prs validate passes
+- prs compile produces correct output
+- No duplicate content across blocks
+`;
+
+// packages/cli/src/utils/manifest-loader.ts
+import { join as join3, dirname as dirname2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+var OFFICIAL_REGISTRY = {
+  name: "PromptScript Official Registry",
+  url: "https://github.com/mrwogu/promptscript-registry.git",
+  branch: "main",
+  manifestUrl: "https://raw.githubusercontent.com/mrwogu/promptscript-registry/main/registry-manifest.yaml"
+};
+var ManifestLoadError = class extends Error {
+  originalCause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "ManifestLoadError";
+    this.originalCause = cause;
+  }
+};
+var manifestCache = /* @__PURE__ */ new Map();
+var MANIFEST_FILENAME = "registry-manifest.yaml";
+async function loadManifest(options = {}, services = createDefaultServices()) {
+  const { registryPath = findDefaultRegistryPath(services), useCache = true } = options;
+  const manifestPath = resolveManifestPath(registryPath, services);
+  if (useCache && manifestCache.has(manifestPath)) {
+    return {
+      manifest: manifestCache.get(manifestPath),
+      path: manifestPath,
+      cached: true
+    };
+  }
+  const manifest = await loadManifestFromPath(manifestPath, services);
+  validateManifest(manifest);
+  if (useCache) {
+    manifestCache.set(manifestPath, manifest);
+  }
+  return {
+    manifest,
+    path: manifestPath,
+    cached: false
+  };
+}
+function findDefaultRegistryPath(services) {
+  const candidates = ["./registry", "../promptscript-registry", "./.promptscript-registry"];
+  for (const candidate of candidates) {
+    const manifestPath = join3(services.cwd, candidate, MANIFEST_FILENAME);
+    if (services.fs.existsSync(manifestPath)) {
+      return candidate;
+    }
+  }
+  return "./registry";
+}
+function resolveManifestPath(registryPath, services) {
+  if (registryPath.endsWith(".yaml") || registryPath.endsWith(".yml")) {
+    return join3(services.cwd, registryPath);
+  }
+  return join3(services.cwd, registryPath, MANIFEST_FILENAME);
+}
+async function loadManifestFromPath(manifestPath, services) {
+  if (!services.fs.existsSync(manifestPath)) {
+    throw new ManifestLoadError(
+      `Registry manifest not found at: ${manifestPath}
+Run \`prs pull\` to fetch the registry or check your registry configuration.`
+    );
+  }
+  try {
+    const content = await services.fs.readFile(manifestPath, "utf-8");
+    const manifest = parseYaml2(content);
+    return manifest;
+  } catch (error) {
+    throw new ManifestLoadError(
+      `Failed to parse manifest: ${manifestPath}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function validateManifest(manifest) {
+  if (!manifest.version) {
+    throw new ManifestLoadError("Manifest missing required field: version");
+  }
+  if (manifest.version !== "1") {
+    throw new ManifestLoadError(`Unsupported manifest version: ${manifest.version}`);
+  }
+  if (!manifest.meta) {
+    throw new ManifestLoadError("Manifest missing required field: meta");
+  }
+  if (!manifest.catalog) {
+    throw new ManifestLoadError("Manifest missing required field: catalog");
+  }
+  if (!Array.isArray(manifest.catalog)) {
+    throw new ManifestLoadError("Manifest catalog must be an array");
+  }
+}
+async function loadManifestFromUrl(url = OFFICIAL_REGISTRY.manifestUrl, useCache = true) {
+  if (useCache && manifestCache.has(url)) {
+    return {
+      manifest: manifestCache.get(url),
+      url,
+      cached: true
+    };
+  }
+  try {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "application/x-yaml, text/yaml, text/plain",
+        "User-Agent": "PromptScript-CLI"
+      }
+    });
+    if (!response.ok) {
+      throw new ManifestLoadError(
+        `Failed to fetch manifest from ${url}: ${response.status} ${response.statusText}`
+      );
+    }
+    const content = await response.text();
+    const manifest = parseYaml2(content);
+    validateManifest(manifest);
+    if (useCache) {
+      manifestCache.set(url, manifest);
+    }
+    return {
+      manifest,
+      url,
+      cached: false
+    };
+  } catch (error) {
+    if (error instanceof ManifestLoadError) {
+      throw error;
+    }
+    throw new ManifestLoadError(
+      `Failed to load manifest from ${url}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function isValidGitUrl(url, allowedHosts) {
+  try {
+    if (url.startsWith("git@")) {
+      const hostMatch = url.match(/^git@([^:]+):/);
+      if (hostMatch && hostMatch[1]) {
+        const host = hostMatch[1];
+        return allowedHosts ? allowedHosts.includes(host) : true;
+      }
+      return false;
+    }
+    if (!url.startsWith("https://") && !url.startsWith("http://")) {
+      return false;
+    }
+    const parsed = new URL(url);
+    if (!parsed.hostname || parsed.hostname.length === 0) {
+      return false;
+    }
+    if (allowedHosts) {
+      return allowedHosts.includes(parsed.hostname);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/utils/suggestion-engine.ts
+async function buildProjectContext(projectInfo, services = createDefaultServices()) {
+  const files = await detectProjectFiles(services);
+  const dependencies = await detectDependencies(services);
+  return {
+    files,
+    dependencies,
+    languages: projectInfo.languages,
+    frameworks: projectInfo.frameworks
+  };
+}
+async function detectProjectFiles(services) {
+  const relevantFiles = [
+    "package.json",
+    "tsconfig.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "pom.xml",
+    "build.gradle",
+    ".git",
+    ".env",
+    ".env.example",
+    "jest.config.js",
+    "vitest.config.ts",
+    "vitest.config.js",
+    "pytest.ini",
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "nuxt.config.js",
+    "nuxt.config.ts",
+    "vite.config.js",
+    "vite.config.ts",
+    "Dockerfile",
+    "docker-compose.yml"
+  ];
+  const existingFiles = [];
+  for (const file of relevantFiles) {
+    if (services.fs.existsSync(file)) {
+      existingFiles.push(file);
+    }
+  }
+  return existingFiles;
+}
+async function detectDependencies(services) {
+  if (!services.fs.existsSync("package.json")) {
+    return [];
+  }
+  try {
+    const content = await services.fs.readFile("package.json", "utf-8");
+    const pkg = JSON.parse(content);
+    return [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})];
+  } catch {
+    return [];
+  }
+}
+function calculateSuggestions(manifest, context) {
+  const result = {
+    inherit: void 0,
+    use: [],
+    skills: [],
+    reasoning: []
+  };
+  const suggestedUse = /* @__PURE__ */ new Set();
+  const suggestedSkills = /* @__PURE__ */ new Set();
+  for (const rule of manifest.suggestionRules) {
+    const match = matchCondition(rule.condition, context);
+    if (match.matches) {
+      if (rule.suggest.inherit) {
+        if (!result.inherit) {
+          result.inherit = rule.suggest.inherit;
+          result.reasoning.push({
+            suggestion: `inherit: ${rule.suggest.inherit}`,
+            reason: match.reason,
+            trigger: match.trigger,
+            matchedValue: match.matchedValue
+          });
+        }
+      }
+      if (rule.suggest.use) {
+        for (const useItem of rule.suggest.use) {
+          if (!suggestedUse.has(useItem)) {
+            suggestedUse.add(useItem);
+            result.use.push(useItem);
+            result.reasoning.push({
+              suggestion: `use: ${useItem}`,
+              reason: match.reason,
+              trigger: match.trigger,
+              matchedValue: match.matchedValue
+            });
+          }
+        }
+      }
+      if (rule.suggest.skills) {
+        for (const skill of rule.suggest.skills) {
+          if (!suggestedSkills.has(skill)) {
+            suggestedSkills.add(skill);
+            result.skills.push(skill);
+            result.reasoning.push({
+              suggestion: `skill: ${skill}`,
+              reason: match.reason,
+              trigger: match.trigger,
+              matchedValue: match.matchedValue
+            });
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function matchCondition(condition, context) {
+  if (condition.always) {
+    return {
+      matches: true,
+      reason: "Default recommendation",
+      trigger: "always"
+    };
+  }
+  if (condition.files) {
+    for (const file of condition.files) {
+      if (context.files.includes(file)) {
+        return {
+          matches: true,
+          reason: `Detected file: ${file}`,
+          trigger: "file",
+          matchedValue: file
+        };
+      }
+    }
+  }
+  if (condition.dependencies) {
+    for (const dep of condition.dependencies) {
+      if (context.dependencies.includes(dep)) {
+        return {
+          matches: true,
+          reason: `Detected dependency: ${dep}`,
+          trigger: "dependency",
+          matchedValue: dep
+        };
+      }
+    }
+  }
+  if (condition.languages) {
+    for (const lang of condition.languages) {
+      if (context.languages.includes(lang)) {
+        return {
+          matches: true,
+          reason: `Detected language: ${lang}`,
+          trigger: "language",
+          matchedValue: lang
+        };
+      }
+    }
+  }
+  if (condition.frameworks) {
+    for (const framework of condition.frameworks) {
+      if (context.frameworks.includes(framework)) {
+        return {
+          matches: true,
+          reason: `Detected framework: ${framework}`,
+          trigger: "framework",
+          matchedValue: framework
+        };
+      }
+    }
+  }
+  return {
+    matches: false,
+    reason: "",
+    trigger: "always"
+  };
+}
+function formatSuggestionResult(result) {
+  const lines = [];
+  if (result.inherit) {
+    lines.push(`\u{1F4E6} Inherit: ${result.inherit}`);
+  }
+  if (result.use.length > 0) {
+    lines.push(`\u{1F527} Use: ${result.use.join(", ")}`);
+  }
+  if (result.skills.length > 0) {
+    lines.push(`\u26A1 Skills: ${result.skills.join(", ")}`);
+  }
+  if (result.reasoning.length > 0) {
+    lines.push("");
+    lines.push("Reasoning:");
+    for (const r of result.reasoning) {
+      lines.push(`  \u2022 ${r.suggestion} (${r.reason})`);
+    }
+  }
+  return lines;
+}
+function createSuggestionChoices(manifest, result) {
+  const choices = [];
+  if (result.inherit) {
+    const entry = manifest.catalog.find((e) => e.id === result.inherit);
+    choices.push({
+      name: `${result.inherit} (inherit)`,
+      value: `inherit:${result.inherit}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  for (const use of result.use) {
+    const entry = manifest.catalog.find((e) => e.id === use);
+    choices.push({
+      name: `${use} (use)`,
+      value: `use:${use}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  for (const skill of result.skills) {
+    const entry = manifest.catalog.find((e) => e.id === skill);
+    choices.push({
+      name: `${skill} (skill)`,
+      value: `skill:${skill}`,
+      checked: true,
+      description: entry?.description
+    });
+  }
+  return choices;
+}
+function parseSelectedChoices(selected) {
+  const result = {
+    use: [],
+    skills: []
+  };
+  for (const choice of selected) {
+    if (choice.startsWith("inherit:")) {
+      result.inherit = choice.slice("inherit:".length);
+    } else if (choice.startsWith("use:")) {
+      result.use.push(choice.slice("use:".length));
+    } else if (choice.startsWith("skill:")) {
+      result.skills.push(choice.slice("skill:".length));
+    }
+  }
+  return result;
+}
+
 // packages/cli/src/commands/init.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
+var __dirname = dirname3(__filename);
 async function initCommand(options, services = createDefaultServices()) {
   const { fs: fs4 } = services;
   if (fs4.existsSync("promptscript.yaml") && !options.force) {
@@ -873,11 +1781,22 @@ async function initCommand(options, services = createDefaultServices()) {
     const projectInfo = await detectProject(services);
     const aiToolsDetection = await detectAITools(services);
     const prettierConfigPath = findPrettierConfig(process.cwd());
+    let manifest;
+    try {
+      const registryPath = options.registry ?? "./registry";
+      const { manifest: loadedManifest } = await loadManifest({ registryPath }, services);
+      manifest = loadedManifest;
+    } catch (error) {
+      if (!(error instanceof ManifestLoadError)) {
+        throw error;
+      }
+    }
     const config = await resolveConfig(
       options,
       projectInfo,
       aiToolsDetection,
       prettierConfigPath,
+      manifest,
       services
     );
     const spinner = createSpinner("Creating PromptScript configuration...").start();
@@ -886,11 +1805,45 @@ async function initCommand(options, services = createDefaultServices()) {
     await fs4.writeFile("promptscript.yaml", configContent, "utf-8");
     const projectPsContent = generateProjectPs(config, projectInfo);
     await fs4.writeFile(".promptscript/project.prs", projectPsContent, "utf-8");
+    const installedSkillPaths = [];
+    if (options.migrate) {
+      if (config.targets.includes("claude")) {
+        await fs4.mkdir(".claude/skills/migrate-to-promptscript", { recursive: true });
+        await fs4.writeFile(
+          ".claude/skills/migrate-to-promptscript/SKILL.md",
+          MIGRATE_SKILL_CLAUDE,
+          "utf-8"
+        );
+        installedSkillPaths.push(".claude/skills/migrate-to-promptscript/SKILL.md");
+      }
+      if (config.targets.includes("github")) {
+        await fs4.mkdir(".github/skills/migrate-to-promptscript", { recursive: true });
+        await fs4.writeFile(
+          ".github/skills/migrate-to-promptscript/SKILL.md",
+          MIGRATE_SKILL_GITHUB,
+          "utf-8"
+        );
+        installedSkillPaths.push(".github/skills/migrate-to-promptscript/SKILL.md");
+      }
+      if (config.targets.includes("cursor")) {
+        await fs4.mkdir(".cursor/commands", { recursive: true });
+        await fs4.writeFile(".cursor/commands/migrate.md", MIGRATE_SKILL_CURSOR, "utf-8");
+        installedSkillPaths.push(".cursor/commands/migrate.md");
+      }
+      if (config.targets.includes("antigravity")) {
+        await fs4.mkdir(".agent/rules", { recursive: true });
+        await fs4.writeFile(".agent/rules/migrate.md", MIGRATE_SKILL_ANTIGRAVITY, "utf-8");
+        installedSkillPaths.push(".agent/rules/migrate.md");
+      }
+    }
     spinner.succeed("PromptScript initialized");
     ConsoleOutput.newline();
     console.log("Created:");
     ConsoleOutput.success("promptscript.yaml");
     ConsoleOutput.success(".promptscript/project.prs");
+    for (const skillPath of installedSkillPaths) {
+      ConsoleOutput.success(skillPath);
+    }
     ConsoleOutput.newline();
     console.log("Configuration:");
     ConsoleOutput.muted(`  Project: ${config.projectId}`);
@@ -899,7 +1852,14 @@ async function initCommand(options, services = createDefaultServices()) {
       ConsoleOutput.muted(`  Inherit: ${config.inherit}`);
     }
     if (config.registry) {
-      ConsoleOutput.muted(`  Registry: ${config.registry}`);
+      if (config.registry.type === "git") {
+        ConsoleOutput.muted(`  Registry: ${config.registry.url} (${config.registry.ref})`);
+      } else {
+        ConsoleOutput.muted(`  Registry: ${config.registry.path} (local)`);
+      }
+    }
+    if (config.use && config.use.length > 0) {
+      ConsoleOutput.muted(`  Use: ${config.use.join(", ")}`);
     }
     ConsoleOutput.newline();
     if (config.prettierConfigPath) {
@@ -911,17 +1871,35 @@ async function initCommand(options, services = createDefaultServices()) {
     }
     ConsoleOutput.newline();
     console.log("Next steps:");
-    ConsoleOutput.muted("1. Edit .promptscript/project.prs to customize your AI instructions");
-    ConsoleOutput.muted("2. Run: prs compile");
-    if (hasMigrationCandidates(aiToolsDetection)) {
-      const migrationHint = formatMigrationHint(aiToolsDetection);
-      for (const line of migrationHint) {
-        if (line.startsWith("\u{1F4CB}") || line.includes("migrated") || line.includes("See:") || line.includes("Or use")) {
-          ConsoleOutput.info(line.replace(/^\s+/, ""));
-        } else if (line.trim().startsWith("\u2022")) {
-          ConsoleOutput.muted(line);
-        } else if (line.trim()) {
-          console.log(line);
+    if (options.migrate && installedSkillPaths.length > 0) {
+      ConsoleOutput.muted("1. Use the migration skill to convert existing instructions:");
+      if (config.targets.includes("claude")) {
+        ConsoleOutput.muted("   Claude Code: /migrate");
+      }
+      if (config.targets.includes("github")) {
+        ConsoleOutput.muted("   GitHub Copilot: @workspace /migrate");
+      }
+      if (config.targets.includes("cursor")) {
+        ConsoleOutput.muted("   Cursor: /migrate");
+      }
+      if (config.targets.includes("antigravity")) {
+        ConsoleOutput.muted('   Antigravity: Ask to "migrate to PromptScript"');
+      }
+      ConsoleOutput.muted("2. Review generated .promptscript/project.prs");
+      ConsoleOutput.muted("3. Run: prs compile");
+    } else {
+      ConsoleOutput.muted("1. Edit .promptscript/project.prs to customize your AI instructions");
+      ConsoleOutput.muted("2. Run: prs compile");
+      if (hasMigrationCandidates(aiToolsDetection)) {
+        const migrationHint = formatMigrationHint(aiToolsDetection);
+        for (const line of migrationHint) {
+          if (line.startsWith("\u{1F4CB}") || line.includes("migrated") || line.includes("See:") || line.includes("Or use")) {
+            ConsoleOutput.info(line.replace(/^\s+/, ""));
+          } else if (line.trim().startsWith("\u2022")) {
+            ConsoleOutput.muted(line);
+          } else if (line.trim()) {
+            console.log(line);
+          }
         }
       }
     }
@@ -935,23 +1913,46 @@ async function initCommand(options, services = createDefaultServices()) {
     process.exit(1);
   }
 }
-async function resolveConfig(options, projectInfo, aiToolsDetection, prettierConfigPath, services) {
+async function resolveConfig(options, projectInfo, aiToolsDetection, prettierConfigPath, manifest, services) {
   if (options.yes) {
+    let inherit = options.inherit;
+    let use;
+    let activeManifest = manifest;
+    if (!activeManifest) {
+      try {
+        const { manifest: remoteManifest } = await loadManifestFromUrl();
+        activeManifest = remoteManifest;
+      } catch {
+      }
+    }
+    if (activeManifest) {
+      const context = await buildProjectContext(projectInfo, services);
+      const suggestions = calculateSuggestions(activeManifest, context);
+      if (!inherit && suggestions.inherit) {
+        inherit = suggestions.inherit;
+      }
+      if (suggestions.use.length > 0) {
+        use = suggestions.use;
+      }
+    }
+    const registry = options.registry ? { type: "local", path: options.registry } : { type: "git", url: OFFICIAL_REGISTRY.url, ref: OFFICIAL_REGISTRY.branch };
     return {
       projectId: options.name ?? projectInfo.name,
       team: options.team,
-      inherit: options.inherit,
-      registry: options.registry ?? "./registry",
+      inherit,
+      use,
+      registry,
       targets: options.targets ?? getSuggestedTargets(aiToolsDetection),
       prettierConfigPath
     };
   }
   if (!options.interactive && options.name && options.targets) {
+    const registry = options.registry ? { type: "local", path: options.registry } : void 0;
     return {
       projectId: options.name,
       team: options.team,
       inherit: options.inherit,
-      registry: options.registry,
+      registry,
       targets: options.targets,
       prettierConfigPath
     };
@@ -961,10 +1962,11 @@ async function resolveConfig(options, projectInfo, aiToolsDetection, prettierCon
     projectInfo,
     aiToolsDetection,
     prettierConfigPath,
+    manifest,
     services
   );
 }
-async function runInteractivePrompts(options, projectInfo, aiToolsDetection, prettierConfigPath, services) {
+async function runInteractivePrompts(options, projectInfo, aiToolsDetection, prettierConfigPath, manifest, services) {
   const { prompts: prompts2 } = services;
   ConsoleOutput.newline();
   console.log("\u{1F680} PromptScript Setup");
@@ -990,33 +1992,124 @@ async function runInteractivePrompts(options, projectInfo, aiToolsDetection, pre
     message: "Project name:",
     default: options.name ?? projectInfo.name
   });
-  const wantsInherit = await prompts2.confirm({
-    message: "Do you want to inherit from a parent configuration?",
-    default: false
+  let registry;
+  let activeManifest = manifest;
+  const registryChoice = await prompts2.select({
+    message: "Registry configuration:",
+    choices: [
+      {
+        name: `\u{1F4E6} Use official PromptScript Registry (${OFFICIAL_REGISTRY.url})`,
+        value: "official"
+      },
+      {
+        name: "\u{1F517} Connect to a custom Git registry",
+        value: "custom-git"
+      },
+      {
+        name: "\u{1F4C1} Use a local registry directory",
+        value: "local"
+      },
+      {
+        name: "\u23ED\uFE0F  Skip registry (configure later)",
+        value: "skip"
+      }
+    ],
+    default: manifest ? "official" : "skip"
   });
-  let inherit;
-  if (wantsInherit) {
-    inherit = await prompts2.input({
-      message: "Inheritance path (e.g., @company/team):",
-      default: options.inherit ?? "@company/team",
+  if (registryChoice === "official") {
+    registry = {
+      type: "git",
+      url: OFFICIAL_REGISTRY.url,
+      ref: OFFICIAL_REGISTRY.branch
+    };
+    if (!activeManifest) {
+      try {
+        ConsoleOutput.muted("Fetching registry manifest...");
+        const { manifest: remoteManifest } = await loadManifestFromUrl();
+        activeManifest = remoteManifest;
+        ConsoleOutput.success(
+          `Loaded ${remoteManifest.catalog.length} configurations from official registry`
+        );
+      } catch {
+        ConsoleOutput.warn("Could not fetch registry manifest - suggestions will be limited");
+      }
+    }
+  } else if (registryChoice === "custom-git") {
+    const gitUrl = await prompts2.input({
+      message: "Git repository URL:",
+      default: "https://github.com/your-org/your-registry.git",
       validate: (value) => {
-        if (!value.startsWith("@")) {
-          return "Inheritance path should start with @";
+        if (!isValidGitUrl(value)) {
+          return "Please enter a valid Git repository URL (https:// or git@)";
         }
         return true;
       }
     });
-  }
-  const wantsRegistry = await prompts2.confirm({
-    message: "Do you want to configure a registry?",
-    default: false
-  });
-  let registry;
-  if (wantsRegistry) {
-    registry = await prompts2.input({
-      message: "Registry path:",
+    const gitRef = await prompts2.input({
+      message: "Branch or tag:",
+      default: "main"
+    });
+    registry = {
+      type: "git",
+      url: gitUrl,
+      ref: gitRef
+    };
+  } else if (registryChoice === "local") {
+    const localPath = await prompts2.input({
+      message: "Local registry path:",
       default: options.registry ?? "./registry"
     });
+    registry = {
+      type: "local",
+      path: localPath
+    };
+  }
+  let inherit = options.inherit;
+  let use;
+  if (activeManifest) {
+    const context = await buildProjectContext(projectInfo, services);
+    const suggestions = calculateSuggestions(activeManifest, context);
+    if (suggestions.inherit || suggestions.use.length > 0) {
+      ConsoleOutput.newline();
+      console.log("\u{1F4E6} Suggested configurations based on your project:");
+      const suggestionLines = formatSuggestionResult(suggestions);
+      for (const line of suggestionLines) {
+        ConsoleOutput.muted(`  ${line}`);
+      }
+      ConsoleOutput.newline();
+      const choices = createSuggestionChoices(activeManifest, suggestions);
+      if (choices.length > 0) {
+        const selected = await prompts2.checkbox({
+          message: "Select configurations to use:",
+          choices: choices.map((c) => ({
+            name: c.description ? `${c.name} - ${c.description}` : c.name,
+            value: c.value,
+            checked: c.checked
+          }))
+        });
+        const parsed = parseSelectedChoices(selected);
+        inherit = parsed.inherit;
+        use = parsed.use.length > 0 ? parsed.use : void 0;
+      }
+    }
+  }
+  if (!inherit) {
+    const wantsInherit = await prompts2.confirm({
+      message: "Do you want to inherit from a parent configuration?",
+      default: false
+    });
+    if (wantsInherit) {
+      inherit = await prompts2.input({
+        message: "Inheritance path (e.g., @stacks/react):",
+        default: options.inherit ?? "@stacks/react",
+        validate: (value) => {
+          if (!value.startsWith("@")) {
+            return "Inheritance path should start with @";
+          }
+          return true;
+        }
+      });
+    }
   }
   const suggestedTargets = getSuggestedTargets(aiToolsDetection);
   const allTargets = getAllTargets();
@@ -1045,6 +2138,7 @@ async function runInteractivePrompts(options, projectInfo, aiToolsDetection, pre
     projectId,
     team,
     inherit,
+    use,
     registry,
     targets,
     prettierConfigPath
@@ -1068,13 +2162,34 @@ function generateConfig(config) {
   if (config.inherit) {
     lines.push(`inherit: '${config.inherit}'`);
   } else {
-    lines.push("# inherit: '@company/team'");
+    lines.push("# inherit: '@stacks/react'");
+  }
+  lines.push("");
+  if (config.use && config.use.length > 0) {
+    lines.push("use:");
+    for (const useItem of config.use) {
+      lines.push(`  - '${useItem}'`);
+    }
+  } else {
+    lines.push("# use:", "#   - '@fragments/testing'", "#   - '@fragments/typescript'");
   }
   lines.push("");
   if (config.registry) {
-    lines.push("registry:", `  path: '${config.registry}'`);
+    if (config.registry.type === "git") {
+      lines.push("registry:", "  git:", `    url: '${config.registry.url}'`);
+      if (config.registry.ref) {
+        lines.push(`    ref: '${config.registry.ref}'`);
+      }
+    } else {
+      lines.push("registry:", `  path: '${config.registry.path}'`);
+    }
   } else {
-    lines.push("# registry:", "#   path: './registry'");
+    lines.push(
+      "# registry:",
+      "#   git:",
+      "#     url: 'https://github.com/mrwogu/promptscript-registry.git'",
+      "#     ref: 'main'"
+    );
   }
   lines.push("", "targets:");
   for (const target of config.targets) {
@@ -1095,7 +2210,13 @@ function generateConfig(config) {
   return lines.join("\n");
 }
 function generateProjectPs(config, projectInfo) {
-  const inheritLine = config.inherit ? `@inherit ${config.inherit}` : "# @inherit @company/team";
+  const inheritLine = config.inherit ? `@inherit ${config.inherit}` : "# @inherit @stacks/react";
+  let useLines = "";
+  if (config.use && config.use.length > 0) {
+    useLines = config.use.map((u) => `@use ${u}`).join("\n");
+  } else {
+    useLines = "# @use @fragments/testing\n# @use @fragments/typescript";
+  }
   const languagesLine = projectInfo.languages.length > 0 ? `  languages: [${projectInfo.languages.join(", ")}]` : "  # languages: [typescript]";
   const frameworksLine = projectInfo.frameworks.length > 0 ? `  frameworks: [${projectInfo.frameworks.join(", ")}]` : "  # frameworks: []";
   const syntaxVersion = getPackageVersion(__dirname, "./package.json");
@@ -1108,11 +2229,12 @@ function generateProjectPs(config, projectInfo) {
 }
 
 ${inheritLine}
+${useLines}
 
 @identity {
   """
   You are working on the ${config.projectId} project.
-  
+
   [Describe your project here]
   """
 }
@@ -1141,7 +2263,7 @@ ${frameworksLine}
 }
 
 // packages/cli/src/commands/compile.ts
-import { resolve as resolve4, dirname as dirname5 } from "path";
+import { resolve as resolve4, dirname as dirname6 } from "path";
 import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync7 } from "fs";
 import chokidar from "chokidar";
@@ -1149,7 +2271,7 @@ import chokidar from "chokidar";
 // packages/cli/src/config/loader.ts
 import { readFile as readFile3 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { parse as parseYaml2 } from "yaml";
+import { parse as parseYaml3 } from "yaml";
 var CONFIG_FILES = [
   "promptscript.yaml",
   "promptscript.yml",
@@ -1196,7 +2318,7 @@ async function loadConfig(customPath) {
   let content = await readFile3(configFile, "utf-8");
   content = interpolateEnvVars(content);
   try {
-    return parseYaml2(content);
+    return parseYaml3(content);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Unknown parse error";
     throw new Error(`Failed to parse ${configFile}: ${message}`);
@@ -1365,10 +2487,26 @@ ${this.convention.rootWrapper.end}`;
   /**
    * Escape markdown special characters for Prettier compatibility.
    * - Escapes __ to \_\_ (to avoid emphasis)
-   * - Escapes /* to /\* (to avoid glob patterns being interpreted)
+   * - Escapes * in glob patterns (like packages/*) outside backticks
    */
   escapeMarkdownSpecialChars(content) {
-    return content.replace(/__/g, "\\_\\_").replace(/\/\*/g, "/\\*");
+    return content.split("\n").map((line) => {
+      let result = line.replace(/__/g, "\\_\\_");
+      result = this.escapeGlobAsteriskOutsideBackticks(result);
+      return result;
+    }).join("\n");
+  }
+  /**
+   * Escape glob asterisks (like packages/* or .cursor/rules/*.md) outside of backticks.
+   */
+  escapeGlobAsteriskOutsideBackticks(line) {
+    const parts = line.split("`");
+    return parts.map((part, index) => {
+      if (index % 2 === 0) {
+        return part.replace(/\/\*/g, "/\\*");
+      }
+      return part;
+    }).join("`");
   }
   indentContent(content, renderer, level) {
     const indent = renderer.indent ?? "";
@@ -1540,6 +2678,7 @@ var BaseFormatter = class {
    * - Trims trailing whitespace from lines
    * - Normalizes markdown table formatting
    * - Adds blank lines before lists when preceded by text
+   * - Adds blank lines before code blocks when preceded by text
    * - Escapes markdown special characters in paths
    */
   normalizeMarkdownForPrettier(content) {
@@ -1548,8 +2687,13 @@ var BaseFormatter = class {
     let inCodeBlock = false;
     for (const line of lines) {
       const trimmed = line.trimEnd();
-      if (trimmed.startsWith("```")) {
+      if (trimmed.trimStart().startsWith("```")) {
         inCodeBlock = !inCodeBlock;
+        if (trimmed.length > 0) {
+          const match2 = line.match(/^(\s*)/);
+          const leadingSpaces2 = match2?.[1]?.length ?? 0;
+          minIndent = Math.min(minIndent, leadingSpaces2);
+        }
         continue;
       }
       if (inCodeBlock) continue;
@@ -1565,17 +2709,30 @@ var BaseFormatter = class {
     inCodeBlock = false;
     for (const line of lines) {
       const trimmedLine = line.trimEnd();
-      if (trimmedLine.trimStart().startsWith("```")) {
+      const unindentedLine = minIndent > 0 ? trimmedLine.slice(minIndent) : trimmedLine;
+      const isCodeBlockMarker = trimmedLine.trimStart().startsWith("```");
+      const isCodeBlockStart = isCodeBlockMarker && !inCodeBlock;
+      if (isCodeBlockMarker) {
         inCodeBlock = !inCodeBlock;
       }
-      const unindentedLine = minIndent > 0 ? trimmedLine.slice(minIndent) : trimmedLine;
       if (inCodeBlock || unindentedLine.startsWith("```")) {
+        if (isCodeBlockStart) {
+          const prevLine2 = result.length > 0 ? result[result.length - 1] ?? "" : "";
+          if (prevLine2.trim() && !prevLine2.startsWith("#")) {
+            result.push("");
+          }
+        }
         result.push(unindentedLine);
         continue;
       }
       let processedLine = unindentedLine;
       processedLine = processedLine.replace(/__([^_]+)__/g, "\\_\\_$1\\_\\_");
-      processedLine = processedLine.replace(/\/\*/g, "/\\*");
+      processedLine = this.escapeGlobAsteriskOutsideBackticks(processedLine);
+      const prevLine = result.length > 0 ? result[result.length - 1] : "";
+      const isHeader = prevLine?.trimStart().startsWith("#");
+      if (isHeader && processedLine.trim()) {
+        result.push("");
+      }
       if (processedLine.trimStart().startsWith("|") && processedLine.trimEnd().endsWith("|")) {
         inTable = true;
         tableLines.push(processedLine.trim());
@@ -1585,9 +2742,14 @@ var BaseFormatter = class {
           tableLines = [];
           inTable = false;
         }
-        const prevLine = result.length > 0 ? result[result.length - 1] : "";
         const isListItem = processedLine.trimStart().startsWith("- ");
-        if (isListItem && prevLine && !prevLine.trimStart().startsWith("- ")) {
+        const isNumberedItem = /^\d+\.\s/.test(processedLine.trimStart());
+        const prevLineTrimmed = prevLine?.trimStart() ?? "";
+        const isPrevListItem = prevLineTrimmed.startsWith("- ") || /^\d+\.\s/.test(prevLineTrimmed);
+        const prevEndsWithColon = prevLine?.trimEnd().endsWith(":") ?? false;
+        if ((isListItem || isNumberedItem) && prevLine && !isPrevListItem && !isHeader) {
+          result.push("");
+        } else if ((isListItem || isNumberedItem) && prevEndsWithColon) {
           result.push("");
         }
         result.push(processedLine);
@@ -1598,6 +2760,19 @@ var BaseFormatter = class {
     }
     return result.join("\n");
   }
+  /**
+   * Escape glob asterisks (like packages/* or .cursor/rules/*.md) outside of backticks.
+   * Prettier escapes these to prevent them from being interpreted as emphasis markers.
+   */
+  escapeGlobAsteriskOutsideBackticks(line) {
+    const parts = line.split("`");
+    return parts.map((part, index) => {
+      if (index % 2 === 0) {
+        return part.replace(/\/\*/g, "/\\*");
+      }
+      return part;
+    }).join("`");
+  }
   /**
    * Strip all leading indentation from markdown content.
    * Used for AGENTS.md where content from multiple sources has inconsistent indentation.
@@ -1611,7 +2786,7 @@ var BaseFormatter = class {
       const trimmedEnd = line.trimEnd();
       if (trimmedEnd.trimStart().startsWith("```")) {
         if (!inCodeBlock) {
-          const prevLine2 = result.length > 0 ? result[result.length - 1] : "";
+          const prevLine2 = result.length > 0 ? result[result.length - 1] ?? "" : "";
           if (prevLine2 && prevLine2.trim()) {
             result.push("");
           }
@@ -1626,9 +2801,14 @@ var BaseFormatter = class {
       }
       let stripped = trimmedEnd.trimStart();
       stripped = stripped.replace(/__/g, "\\_\\_");
-      stripped = stripped.replace(/\/\*/g, "/\\*");
-      const prevLine = result.length > 0 ? result[result.length - 1] : "";
-      if (stripped.startsWith("- ") && prevLine && !prevLine.startsWith("- ")) {
+      stripped = this.escapeGlobAsteriskOutsideBackticks(stripped);
+      const prevLine = result.length > 0 ? result[result.length - 1] ?? "" : "";
+      const isListItem = stripped.startsWith("- ") || /^\d+\.\s/.test(stripped);
+      const isPrevList = prevLine.startsWith("- ") || /^\d+\.\s/.test(prevLine);
+      const prevEndsWithColon = prevLine.trimEnd().endsWith(":");
+      if (isListItem && prevLine && !isPrevList) {
+        result.push("");
+      } else if (isListItem && prevEndsWithColon) {
         result.push("");
       }
       result.push(stripped);
@@ -1969,7 +3149,9 @@ var GitHubFormatter = class extends BaseFormatter {
     lines.push(`# ${config.description}`);
     lines.push("");
     if (config.content) {
-      lines.push(config.content);
+      const dedentedContent = this.dedent(config.content);
+      const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
+      lines.push(normalizedContent);
     }
     return {
       path: `.github/instructions/${config.name}.instructions.md`,
@@ -2057,7 +3239,8 @@ var GitHubFormatter = class extends BaseFormatter {
   generatePromptFile(config) {
     const lines = [];
     lines.push("---");
-    lines.push(`description: "${config.description}"`);
+    const descQuote = config.description.includes("'") ? '"' : "'";
+    lines.push(`description: ${descQuote}${config.description}${descQuote}`);
     if (config.mode === "agent") {
       lines.push("mode: agent");
       if (config.tools && config.tools.length > 0) {
@@ -2069,11 +3252,13 @@ var GitHubFormatter = class extends BaseFormatter {
     lines.push("---");
     lines.push("");
     if (config.content) {
-      lines.push(config.content);
+      const dedentedContent = this.dedent(config.content);
+      const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
+      lines.push(normalizedContent);
     }
     return {
       path: `.github/prompts/${config.name}.prompt.md`,
-      content: lines.join("\n")
+      content: lines.join("\n") + "\n"
     };
   }
   // ============================================================
@@ -2115,7 +3300,8 @@ var GitHubFormatter = class extends BaseFormatter {
     lines.push("---");
     lines.push("");
     if (config.content) {
-      const normalizedContent = this.normalizeMarkdownForPrettier(config.content);
+      const dedentedContent = this.dedent(config.content);
+      const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
       lines.push(normalizedContent);
     }
     return {
@@ -2123,6 +3309,28 @@ var GitHubFormatter = class extends BaseFormatter {
       content: lines.join("\n") + "\n"
     };
   }
+  /**
+   * Remove common leading indentation from multiline text.
+   * Calculates minimum indent from lines 2+ only, since line 1 may have been
+   * trimmed (losing its indentation) while subsequent lines retain theirs.
+   */
+  dedent(text) {
+    const lines = text.split("\n");
+    if (lines.length <= 1) return text.trim();
+    const minIndent = lines.slice(1).filter((line) => line.trim().length > 0).reduce((min, line) => {
+      const match = line.match(/^(\s*)/);
+      const indent = match?.[1]?.length ?? 0;
+      return Math.min(min, indent);
+    }, Infinity);
+    if (minIndent === 0 || minIndent === Infinity) {
+      return text.trim();
+    }
+    const firstLine = lines[0] ?? "";
+    return [
+      firstLine.trim(),
+      ...lines.slice(1).map((line) => line.trim().length > 0 ? line.slice(minIndent) : "")
+    ].join("\n").trim();
+  }
   // ============================================================
   // AGENTS.md Generation
   // ============================================================
@@ -2258,7 +3466,9 @@ var GitHubFormatter = class extends BaseFormatter {
     lines.push("---");
     lines.push("");
     if (config.content) {
-      lines.push(config.content);
+      const dedentedContent = this.dedent(config.content);
+      const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
+      lines.push(normalizedContent);
     }
     return {
       path: `.github/agents/${config.name}.md`,
@@ -2713,7 +3923,9 @@ var ClaudeFormatter = class extends BaseFormatter {
     lines.push(`# ${config.description}`);
     lines.push("");
     if (config.content) {
-      lines.push(config.content);
+      const dedentedContent = this.dedent(config.content);
+      const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
+      lines.push(normalizedContent);
     }
     return {
       path: `.claude/rules/${config.name}.md`,
@@ -2812,7 +4024,8 @@ var ClaudeFormatter = class extends BaseFormatter {
     lines.push("---");
     lines.push("");
     if (config.content) {
-      const normalizedContent = this.normalizeMarkdownForPrettier(config.content);
+      const dedentedContent = this.dedent(config.content);
+      const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
       lines.push(normalizedContent);
     }
     return {
@@ -2820,6 +4033,28 @@ var ClaudeFormatter = class extends BaseFormatter {
       content: lines.join("\n") + "\n"
     };
   }
+  /**
+   * Remove common leading indentation from multiline text.
+   * Calculates minimum indent from lines 2+ only, since line 1 may have been
+   * trimmed (losing its indentation) while subsequent lines retain theirs.
+   */
+  dedent(text) {
+    const lines = text.split("\n");
+    if (lines.length <= 1) return text.trim();
+    const minIndent = lines.slice(1).filter((line) => line.trim().length > 0).reduce((min, line) => {
+      const match = line.match(/^(\s*)/);
+      const indent = match?.[1]?.length ?? 0;
+      return Math.min(min, indent);
+    }, Infinity);
+    if (minIndent === 0 || minIndent === Infinity) {
+      return text.trim();
+    }
+    const firstLine = lines[0] ?? "";
+    return [
+      firstLine.trim(),
+      ...lines.slice(1).map((line) => line.trim().length > 0 ? line.slice(minIndent) : "")
+    ].join("\n").trim();
+  }
   // ============================================================
   // Agent File Generation
   // ============================================================
@@ -2922,7 +4157,9 @@ var ClaudeFormatter = class extends BaseFormatter {
     lines.push("---");
     lines.push("");
     if (config.content) {
-      lines.push(config.content);
+      const dedentedContent = this.dedent(config.content);
+      const normalizedContent = this.normalizeMarkdownForPrettier(dedentedContent);
+      lines.push(normalizedContent);
     }
     return {
       path: `.claude/agents/${config.name}.md`,
@@ -2977,7 +4214,8 @@ var ClaudeFormatter = class extends BaseFormatter {
     const cleanText = text.split(/\n{2,}/).map(
       (para) => para.split("\n").map((line) => line.trim()).filter((line) => line).join("\n")
     ).filter((para) => para).join("\n\n");
-    return renderer.renderSection("Project", cleanText) + "\n";
+    const normalizedText = this.normalizeMarkdownForPrettier(cleanText);
+    return renderer.renderSection("Project", normalizedText) + "\n";
   }
   techStack(ast, renderer) {
     const context = this.findBlock(ast, "context");
@@ -3035,8 +4273,9 @@ var ClaudeFormatter = class extends BaseFormatter {
     const text = this.extractText(context.content);
     const archMatch = this.extractSectionWithCodeBlock(text, "## Architecture");
     if (!archMatch) return null;
-    const content = archMatch.replace("## Architecture", "").trim();
-    return renderer.renderSection("Architecture", content) + "\n";
+    const content = archMatch.replace("## Architecture", "");
+    const normalizedContent = this.normalizeMarkdownForPrettier(content);
+    return renderer.renderSection("Architecture", normalizedContent.trim()) + "\n";
   }
   codeStandards(ast, renderer) {
     const standards = this.findBlock(ast, "standards");
@@ -3117,7 +4356,7 @@ var ClaudeFormatter = class extends BaseFormatter {
       const props = this.getProps(shortcuts.content);
       for (const [cmd, desc] of Object.entries(props)) {
         const shortDesc = this.valueToString(desc).split("\n")[0] ?? "";
-        commandLines.push(`${cmd.padEnd(10)} - ${shortDesc}`);
+        commandLines.push(`${cmd.padEnd(10)} - ${shortDesc}`.trimEnd());
       }
     }
     if (commandLines.length === 0) return null;
@@ -3126,8 +4365,9 @@ var ClaudeFormatter = class extends BaseFormatter {
       const text = this.extractText(knowledge.content);
       const match = this.extractSectionWithCodeBlock(text, "## Development Commands");
       if (match) {
-        const devCmds = match.replace("## Development Commands", "").trim();
-        content += "\n\n" + devCmds;
+        const devCmds = match.replace("## Development Commands", "");
+        const normalizedDevCmds = this.normalizeMarkdownForPrettier(devCmds);
+        content += "\n\n" + normalizedDevCmds.trim();
       }
     }
     return renderer.renderSection("Commands", content) + "\n";
@@ -3138,8 +4378,9 @@ var ClaudeFormatter = class extends BaseFormatter {
     const text = this.extractText(knowledge.content);
     const match = this.extractSectionWithCodeBlock(text, "## Post-Work Verification");
     if (!match) return null;
-    const content = match.replace("## Post-Work Verification", "").trim();
-    return renderer.renderSection("Post-Work Verification", content) + "\n";
+    const content = match.replace("## Post-Work Verification", "");
+    const normalizedContent = this.normalizeMarkdownForPrettier(content);
+    return renderer.renderSection("Post-Work Verification", normalizedContent.trim()) + "\n";
   }
   documentation(ast, renderer) {
     const standards = this.findBlock(ast, "standards");
@@ -3517,13 +4758,39 @@ var CursorFormatter = class extends BaseFormatter {
     if (never) sections.push(never);
   }
   intro(ast) {
-    const projectInfo = this.extractProjectInfo(ast);
-    if (projectInfo.text.toLowerCase().startsWith("you are")) {
-      return projectInfo.text;
+    const identity2 = this.findBlock(ast, "identity");
+    if (identity2) {
+      const fullText = this.dedent(this.extractText(identity2.content));
+      if (fullText.toLowerCase().startsWith("you are")) {
+        return fullText;
+      }
     }
+    const projectInfo = this.extractProjectInfo(ast);
     const orgSuffix = projectInfo.org ? ` at ${projectInfo.org}` : "";
     return `You are working on ${projectInfo.text}${orgSuffix}.`;
   }
+  /**
+   * Remove common leading whitespace from all lines (dedent).
+   * Handles the case where trim() was already called, causing the first line
+   * to lose its indentation while subsequent lines retain theirs.
+   */
+  dedent(text) {
+    const lines = text.split("\n");
+    if (lines.length <= 1) return text.trim();
+    const minIndent = lines.slice(1).filter((line) => line.trim().length > 0).reduce((min, line) => {
+      const match = line.match(/^(\s*)/);
+      const indent = match?.[1]?.length ?? 0;
+      return Math.min(min, indent);
+    }, Infinity);
+    if (minIndent === 0 || minIndent === Infinity) {
+      return text.trim();
+    }
+    const firstLine = lines[0] ?? "";
+    return [
+      firstLine.trim(),
+      ...lines.slice(1).map((line) => line.trim().length > 0 ? line.slice(minIndent) : "")
+    ].join("\n").trim();
+  }
   /**
    * Generate YAML frontmatter for Cursor MDC format.
    * @see https://cursor.com/docs/context/rules
@@ -14613,7 +15880,7 @@ function parse(source, options = {}) {
 
 // packages/resolver/src/loader.ts
 import { readFile as readFile4 } from "fs/promises";
-import { resolve as resolve2, dirname as dirname3, isAbsolute } from "path";
+import { resolve as resolve2, dirname as dirname4, isAbsolute } from "path";
 var FileLoader = class {
   registryPath;
   localPath;
@@ -14674,7 +15941,7 @@ var FileLoader = class {
    */
   resolveRef(ref, fromFile) {
     if (ref.isRelative) {
-      const dir = dirname3(fromFile);
+      const dir = dirname4(fromFile);
       const rawPath = ref.raw.endsWith(".prs") ? ref.raw : `${ref.raw}.prs`;
       return resolve2(dir, rawPath);
     }
@@ -15336,7 +16603,7 @@ function uniqueConcat3(parent, child) {
 
 // packages/resolver/src/skills.ts
 import { readFile as readFile5, access } from "fs/promises";
-import { resolve as resolve3, dirname as dirname4 } from "path";
+import { resolve as resolve3, dirname as dirname5 } from "path";
 function parseSkillMd(content) {
   const lines = content.split("\n");
   let inFrontmatter = false;
@@ -15391,7 +16658,7 @@ async function resolveNativeSkills(ast, registryPath, sourceFile) {
   const skillsContent = skillsBlock.content;
   const updatedProperties = { ...skillsContent.properties };
   let hasUpdates = false;
-  const sourceDir = dirname4(sourceFile);
+  const sourceDir = dirname5(sourceFile);
   const isSkillsDir = sourceDir.includes("@skills");
   for (const [skillName, skillValue] of Object.entries(skillsContent.properties)) {
     if (typeof skillValue !== "object" || skillValue === null || Array.isArray(skillValue)) {
@@ -15619,7 +16886,7 @@ var Resolver = class {
 
 // packages/resolver/src/registry.ts
 import { existsSync as existsSync4, promises as fs } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var FileSystemRegistry = class {
   rootPath;
   constructor(options) {
@@ -15629,7 +16896,7 @@ var FileSystemRegistry = class {
    * Resolve a path relative to the registry root.
    */
   resolvePath(path) {
-    return join3(this.rootPath, path);
+    return join4(this.rootPath, path);
   }
   async fetch(path) {
     const fullPath = this.resolvePath(path);
@@ -15844,12 +17111,12 @@ function createHttpRegistry(options) {
 
 // packages/resolver/src/git-registry.ts
 import { existsSync as existsSync6, promises as fs3 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { simpleGit } from "simple-git";
 
 // packages/resolver/src/git-cache-manager.ts
 import { existsSync as existsSync5, promises as fs2 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { homedir } from "os";
 
 // packages/resolver/src/git-url-utils.ts
@@ -15957,7 +17224,7 @@ function parseVersionedPath(path) {
 }
 
 // packages/resolver/src/git-cache-manager.ts
-var DEFAULT_CACHE_DIR = join4(homedir(), ".promptscript", ".cache", "git");
+var DEFAULT_CACHE_DIR = join5(homedir(), ".promptscript", ".cache", "git");
 var DEFAULT_TTL = 36e5;
 var METADATA_FILE = ".prs-cache-meta.json";
 var GitCacheManager = class {
@@ -15976,7 +17243,7 @@ var GitCacheManager = class {
    */
   getCachePath(url, ref) {
     const cacheKey = getCacheKey(url, ref);
-    return join4(this.cacheDir, cacheKey);
+    return join5(this.cacheDir, cacheKey);
   }
   /**
    * Check if a cache entry exists and is not stale.
@@ -16082,7 +17349,7 @@ var GitCacheManager = class {
       if (!dir.isDirectory()) {
         continue;
       }
-      const cachePath = join4(this.cacheDir, dir.name);
+      const cachePath = join5(this.cacheDir, dir.name);
       const metadata = await this.readMetadata(cachePath);
       if (metadata) {
         const isStale = Date.now() - metadata.lastUpdated > this.ttl;
@@ -16130,7 +17397,7 @@ var GitCacheManager = class {
     let size = 0;
     const entries = await fs2.readdir(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join4(dirPath, entry.name);
+      const fullPath = join5(dirPath, entry.name);
       if (entry.isDirectory()) {
         size += await this.calculateDirSize(fullPath);
       } else {
@@ -16144,7 +17411,7 @@ var GitCacheManager = class {
    * Read metadata from a cache directory.
    */
   async readMetadata(cachePath) {
-    const metadataPath = join4(cachePath, METADATA_FILE);
+    const metadataPath = join5(cachePath, METADATA_FILE);
     if (!existsSync5(metadataPath)) {
       return null;
     }
@@ -16159,7 +17426,7 @@ var GitCacheManager = class {
    * Write metadata to a cache directory.
    */
   async writeMetadata(cachePath, metadata) {
-    const metadataPath = join4(cachePath, METADATA_FILE);
+    const metadataPath = join5(cachePath, METADATA_FILE);
     await fs2.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
   }
 };
@@ -16450,9 +17717,9 @@ var GitRegistry = class {
       cleanPath += ".prs";
     }
     if (this.subPath) {
-      return join5(repoPath, this.subPath, cleanPath);
+      return join6(repoPath, this.subPath, cleanPath);
     }
-    return join5(repoPath, cleanPath);
+    return join6(repoPath, cleanPath);
   }
   /**
    * Resolve a directory path within the repository.
@@ -16462,9 +17729,9 @@ var GitRegistry = class {
    */
   resolveDirectoryPath(repoPath, relativePath) {
     if (this.subPath) {
-      return join5(repoPath, this.subPath, relativePath);
+      return join6(repoPath, this.subPath, relativePath);
     }
-    return join5(repoPath, relativePath);
+    return join6(repoPath, relativePath);
   }
   /**
    * Check if an error is an authentication error.
@@ -17182,8 +18449,8 @@ var Compiler = class _Compiler {
    */
   async watch(entryPath, options = {}) {
     const { default: chokidar2 } = await import("chokidar");
-    const { dirname: dirname8, resolve: resolve9 } = await import("path");
-    const baseDir = dirname8(resolve9(entryPath));
+    const { dirname: dirname10, resolve: resolve9 } = await import("path");
+    const baseDir = dirname10(resolve9(entryPath));
     const includePatterns = options.include ?? ["**/*.prs"];
     const excludePatterns = options.exclude ?? ["**/node_modules/**"];
     const debounceMs = options.debounce ?? 300;
@@ -17403,6 +18670,69 @@ function createPager(enabled = true) {
   return new Pager(enabled);
 }
 
+// packages/cli/src/utils/registry-resolver.ts
+import { join as join7 } from "path";
+async function resolveRegistryPath(config) {
+  if (config.registry?.git) {
+    const gitConfig = config.registry.git;
+    const ref = gitConfig.ref ?? "main";
+    const cacheManager = new GitCacheManager({
+      ttl: config.registry.cache?.ttl
+    });
+    const normalizedUrl = normalizeGitUrl(gitConfig.url);
+    const cachePath = cacheManager.getCachePath(normalizedUrl, ref);
+    const isValid = await cacheManager.isValid(normalizedUrl, ref);
+    if (isValid) {
+      const subPath2 = gitConfig.path ?? "";
+      return {
+        path: subPath2 ? join7(cachePath, subPath2) : cachePath,
+        isRemote: true,
+        source: "git"
+      };
+    }
+    const registry = createGitRegistry({
+      url: gitConfig.url,
+      ref,
+      path: gitConfig.path,
+      auth: gitConfig.auth,
+      cache: {
+        enabled: config.registry.cache?.enabled ?? true,
+        ttl: config.registry.cache?.ttl
+      }
+    });
+    try {
+      await registry.fetch("registry-manifest.yaml");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes("not found") && !message.includes("FileNotFoundError")) {
+        throw new Error(
+          `Failed to clone registry from ${gitConfig.url}: ${message}. Please check your network connection and registry configuration.`
+        );
+      }
+    }
+    const subPath = gitConfig.path ?? "";
+    return {
+      path: subPath ? join7(cachePath, subPath) : cachePath,
+      isRemote: true,
+      source: "git"
+    };
+  }
+  if (config.registry?.url) {
+    const localPath = config.registry?.path ?? "./registry";
+    return {
+      path: localPath,
+      isRemote: true,
+      source: "http"
+    };
+  }
+  const registryPath = config.registry?.path ?? "./registry";
+  return {
+    path: registryPath,
+    isRemote: false,
+    source: "local"
+  };
+}
+
 // packages/cli/src/commands/compile.ts
 var PROMPTSCRIPT_MARKERS = [
   "<!-- PromptScript",
@@ -17410,6 +18740,10 @@ var PROMPTSCRIPT_MARKERS = [
   "> Auto-generated by PromptScript"
   // Legacy - for backwards compatibility
 ];
+var MARKER_REGEX = /<!-- PromptScript [^>]+ -->\n*/g;
+function stripMarkers(content) {
+  return content.replace(MARKER_REGEX, "");
+}
 function createCliLogger() {
   return {
     verbose: (message) => {
@@ -17468,7 +18802,7 @@ function printErrors(errors) {
   }
 }
 async function writeOutputs(outputs, options, _config, services) {
-  const result = { written: [], skipped: [] };
+  const result = { written: [], skipped: [], unchanged: [] };
   let overwriteAll = false;
   const conflicts = [];
   for (const output of outputs.values()) {
@@ -17478,18 +18812,28 @@ async function writeOutputs(outputs, options, _config, services) {
       if (fileExists2) {
         const isGenerated2 = await isPromptScriptGenerated2(outputPath);
         if (isGenerated2) {
-          ConsoleOutput.dryRun(`Would overwrite: ${outputPath}`);
+          const existingContent = await readFile6(outputPath, "utf-8");
+          const existingWithoutMarker = stripMarkers(existingContent);
+          const newWithoutMarker = stripMarkers(output.content);
+          if (existingWithoutMarker === newWithoutMarker) {
+            ConsoleOutput.dryRun(`Unchanged: ${outputPath}`);
+            result.unchanged.push(outputPath);
+          } else {
+            ConsoleOutput.dryRun(`Would overwrite: ${outputPath}`);
+            result.written.push(outputPath);
+          }
         } else {
           ConsoleOutput.warning(`Would conflict: ${outputPath} (not generated by PromptScript)`);
+          result.written.push(outputPath);
         }
       } else {
         ConsoleOutput.dryRun(`Would write: ${outputPath}`);
+        result.written.push(outputPath);
       }
-      result.written.push(outputPath);
       continue;
     }
     if (!fileExists2) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
@@ -17497,14 +18841,22 @@ async function writeOutputs(outputs, options, _config, services) {
     }
     const isGenerated = await isPromptScriptGenerated2(outputPath);
     if (isGenerated) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      const existingContent = await readFile6(outputPath, "utf-8");
+      const existingWithoutMarker = stripMarkers(existingContent);
+      const newWithoutMarker = stripMarkers(output.content);
+      if (existingWithoutMarker === newWithoutMarker) {
+        ConsoleOutput.unchanged(outputPath);
+        result.unchanged.push(outputPath);
+        continue;
+      }
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
       continue;
     }
     if (options.force || overwriteAll) {
-      await mkdir2(dirname5(outputPath), { recursive: true });
+      await mkdir2(dirname6(outputPath), { recursive: true });
       await writeFile2(outputPath, output.content, "utf-8");
       ConsoleOutput.success(outputPath);
       result.written.push(outputPath);
@@ -17517,7 +18869,7 @@ async function writeOutputs(outputs, options, _config, services) {
     const response = await promptForOverwrite(outputPath, services);
     switch (response) {
       case "yes":
-        await mkdir2(dirname5(outputPath), { recursive: true });
+        await mkdir2(dirname6(outputPath), { recursive: true });
         await writeFile2(outputPath, output.content, "utf-8");
         ConsoleOutput.success(outputPath);
         result.written.push(outputPath);
@@ -17528,7 +18880,7 @@ async function writeOutputs(outputs, options, _config, services) {
         break;
       case "all":
         overwriteAll = true;
-        await mkdir2(dirname5(outputPath), { recursive: true });
+        await mkdir2(dirname6(outputPath), { recursive: true });
         await writeFile2(outputPath, output.content, "utf-8");
         ConsoleOutput.success(outputPath);
         result.written.push(outputPath);
@@ -17567,10 +18919,20 @@ async function compileCommand(options, services = createDefaultServices()) {
   try {
     logger.verbose("Loading configuration...");
     const config = await loadConfig(options.config);
-    spinner.text = "Compiling...";
     const selectedTarget = options.target ?? options.format;
     const targets = selectedTarget ? [{ name: selectedTarget }] : parseTargets(config.targets);
-    const registryPath = options.registry ?? config.registry?.path ?? "./registry";
+    let registryPath;
+    if (options.registry) {
+      registryPath = options.registry;
+    } else {
+      spinner.text = "Resolving registry...";
+      const registry = await resolveRegistryPath(config);
+      registryPath = registry.path;
+      if (registry.isRemote) {
+        logger.verbose(`Using cached git registry: ${registryPath}`);
+      }
+    }
+    spinner.text = "Compiling...";
     logger.verbose(`Registry: ${registryPath}`);
     logger.debug(`Config: ${JSON.stringify(config, null, 2)}`);
     const prettierOptions = await resolvePrettierOptions(config, process.cwd());
@@ -17602,6 +18964,9 @@ async function compileCommand(options, services = createDefaultServices()) {
     spinner.succeed("Compilation successful");
     ConsoleOutput.newline();
     const writeResult = await writeOutputs(result.outputs, options, config, services);
+    if (writeResult.unchanged.length > 0) {
+      ConsoleOutput.muted(`Unchanged ${writeResult.unchanged.length} file(s)`);
+    }
     if (writeResult.skipped.length > 0) {
       ConsoleOutput.muted(`Skipped ${writeResult.skipped.length} file(s)`);
     }
@@ -17743,10 +19108,12 @@ async function validateCommand(options) {
   const spinner = isJsonFormat ? createSpinner("").stop() : createSpinner("Loading configuration...").start();
   try {
     const config = await loadConfig();
+    if (!isJsonFormat) spinner.text = "Resolving registry...";
+    const registry = await resolveRegistryPath(config);
     if (!isJsonFormat) spinner.text = "Validating...";
     const compiler = new Compiler({
       resolver: {
-        registryPath: config.registry?.path ?? "./registry",
+        registryPath: registry.path,
         localPath: "./.promptscript"
       },
       validator: config.validation,
@@ -17795,7 +19162,7 @@ function outputJsonResult(result) {
 // packages/cli/src/commands/pull.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { resolve as resolve6, dirname as dirname6 } from "path";
+import { resolve as resolve6, dirname as dirname7 } from "path";
 async function pullCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
   try {
@@ -17834,7 +19201,7 @@ async function pullCommand(options) {
       }
       return;
     }
-    await mkdir3(dirname6(destPath), { recursive: true });
+    await mkdir3(dirname7(destPath), { recursive: true });
     await writeFile3(destPath, content, "utf-8");
     spinner.succeed("Pulled from registry");
     ConsoleOutput.success(destPath);
@@ -17990,11 +19357,13 @@ async function diffCommand(options) {
   const spinner = createSpinner("Loading configuration...").start();
   try {
     const config = await loadConfig();
+    spinner.text = "Resolving registry...";
+    const registry = await resolveRegistryPath(config);
     spinner.text = "Compiling...";
     const targets = options.target ? [{ name: options.target }] : parseTargets2(config.targets);
     const compiler = new Compiler({
       resolver: {
-        registryPath: config.registry?.path ?? "./registry",
+        registryPath: registry.path,
         localPath: "./.promptscript"
       },
       validator: config.validation,
@@ -18228,11 +19597,189 @@ function printResults(results) {
   }
 }
 
-// packages/cli/src/cli.ts
+// packages/cli/src/commands/update-check.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname8 } from "path";
+
+// packages/cli/src/utils/version-check.ts
+import { homedir as homedir2 } from "os";
+import { join as join8 } from "path";
+import { existsSync as existsSync12, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@promptscript/cli/latest";
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function getCacheDir() {
+  return join8(homedir2(), ".promptscript", ".cache");
+}
+function getCachePath() {
+  return join8(getCacheDir(), "version.json");
+}
+function readCache() {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync12(cachePath)) {
+      return null;
+    }
+    const content = readFileSync3(cachePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    const cacheDir = getCacheDir();
+    if (!existsSync12(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
+    }
+    const cachePath = getCachePath();
+    writeFileSync(cachePath, JSON.stringify(cache, null, 2), "utf-8");
+  } catch {
+  }
+}
+function isCacheValid(cache) {
+  try {
+    const lastCheck = new Date(cache.lastCheck).getTime();
+    const now = Date.now();
+    return now - lastCheck < CACHE_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      if (isVerbose()) {
+        ConsoleOutput.verbose(`Could not check for updates: HTTP ${response.status}`);
+      }
+      return null;
+    }
+    const data = await response.json();
+    return data.version ?? null;
+  } catch (error) {
+    if (isVerbose()) {
+      const code = error.code;
+      const message = error instanceof Error ? error.message : "Unknown error";
+      ConsoleOutput.verbose(`Could not check for updates: ${code ?? message}`);
+    }
+    return null;
+  }
+}
+function isNewerVersion(currentVersion, latestVersion) {
+  const cleanCurrent = currentVersion.replace(/^v/, "");
+  const cleanLatest = latestVersion.replace(/^v/, "");
+  const [currentBase, currentPrerelease] = cleanCurrent.split("-");
+  const [latestBase, latestPrerelease] = cleanLatest.split("-");
+  const currentParts = (currentBase ?? "").split(".").map((p) => parseInt(p, 10) || 0);
+  const latestParts = (latestBase ?? "").split(".").map((p) => parseInt(p, 10) || 0);
+  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
+    const c = currentParts[i] ?? 0;
+    const l = latestParts[i] ?? 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  if (currentPrerelease && !latestPrerelease) {
+    return true;
+  }
+  return false;
+}
+async function checkForUpdates(currentVersion) {
+  if (process.env["PROMPTSCRIPT_NO_UPDATE_CHECK"]) {
+    return null;
+  }
+  if (isQuiet()) {
+    return null;
+  }
+  const cache = readCache();
+  if (cache && isCacheValid(cache) && cache.currentVersion === currentVersion) {
+    if (isNewerVersion(currentVersion, cache.latestVersion)) {
+      return {
+        currentVersion,
+        latestVersion: cache.latestVersion,
+        updateAvailable: true
+      };
+    }
+    return null;
+  }
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    return null;
+  }
+  writeCache({
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    latestVersion,
+    currentVersion
+  });
+  if (isNewerVersion(currentVersion, latestVersion)) {
+    return {
+      currentVersion,
+      latestVersion,
+      updateAvailable: true
+    };
+  }
+  return null;
+}
+async function forceCheckForUpdates(currentVersion) {
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    return { info: null, error: true };
+  }
+  writeCache({
+    lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+    latestVersion,
+    currentVersion
+  });
+  const updateAvailable = isNewerVersion(currentVersion, latestVersion);
+  return {
+    info: {
+      currentVersion,
+      latestVersion,
+      updateAvailable
+    },
+    error: false
+  };
+}
+function printUpdateNotification(info) {
+  console.log(
+    `Update available: ${info.currentVersion} \u2192 ${info.latestVersion} (npm i -g @promptscript/cli)`
+  );
+}
+
+// packages/cli/src/commands/update-check.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname7(__filename2);
+var __dirname2 = dirname8(__filename2);
+async function updateCheckCommand() {
+  const currentVersion = getPackageVersion(__dirname2, "../../package.json");
+  console.log(`@promptscript/cli v${currentVersion}`);
+  const { info, error } = await forceCheckForUpdates(currentVersion);
+  if (error) {
+    ConsoleOutput.error("Could not check for updates");
+    process.exitCode = 1;
+    return;
+  }
+  if (info?.updateAvailable) {
+    console.log(
+      `Update available: ${info.currentVersion} \u2192 ${info.latestVersion} (npm i -g @promptscript/cli)`
+    );
+  } else {
+    ConsoleOutput.success("Up to date");
+  }
+}
+
+// packages/cli/src/cli.ts
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname9(__filename3);
 var program = new Command();
-program.name("prs").description("PromptScript CLI - Standardize AI instructions").version(getPackageVersion(__dirname2, "./package.json")).option("--verbose", "Enable verbose output").option("--debug", "Enable debug output (includes verbose)").option("--quiet", "Suppress non-error output").hook("preAction", (thisCommand) => {
+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();
   if (opts["quiet"]) {
     setContext({ logLevel: 0 /* Quiet */ });
@@ -18246,13 +19793,22 @@ program.name("prs").description("PromptScript CLI - Standardize AI instructions"
   } else if (process.env["PROMPTSCRIPT_VERBOSE"] === "1" || process.env["PROMPTSCRIPT_VERBOSE"] === "true") {
     setContext({ logLevel: 2 /* Verbose */ });
   }
+  if (actionCommand.name() === "update-check") {
+    return;
+  }
+  const currentVersion = getPackageVersion(__dirname3, "../package.json");
+  const updateInfo = await checkForUpdates(currentVersion);
+  if (updateInfo) {
+    printUpdateNotification(updateInfo);
+  }
 });
-program.command("init").description("Initialize PromptScript in current directory").option("-n, --name <name>", "Project name (auto-detected from package.json, etc.)").option("-t, --team <team>", "Team namespace").option("--inherit <path>", "Inheritance path (e.g., @company/team)").option("--registry <path>", "Registry path").option("--targets <targets...>", "Target AI tools (github, claude, cursor)").option("-i, --interactive", "Force interactive mode").option("-y, --yes", "Skip prompts, use defaults").option("-f, --force", "Force reinitialize even if already initialized").action((opts) => initCommand(opts));
+program.command("init").description("Initialize PromptScript in current directory").option("-n, --name <name>", "Project name (auto-detected from package.json, etc.)").option("-t, --team <team>", "Team namespace").option("--inherit <path>", "Inheritance path (e.g., @company/team)").option("--registry <path>", "Registry path").option("--targets <targets...>", "Target AI tools (github, claude, cursor)").option("-i, --interactive", "Force interactive mode").option("-y, --yes", "Skip prompts, use defaults").option("-f, --force", "Force reinitialize even if already initialized").option("-m, --migrate", "Install migration skill for AI-assisted migration").action((opts) => initCommand(opts));
 program.command("compile").description("Compile PromptScript to target formats").option("-t, --target <target>", "Specific target (github, claude, cursor)").option("-f, --format <format>", "Output format (alias for --target)").option("-a, --all", "All configured targets", true).option("-w, --watch", "Watch mode").option("-o, --output <dir>", "Output directory").option("--dry-run", "Preview changes").option("--registry <path>", "Registry path (overrides config)").option("-c, --config <path>", "Path to custom config file").option("--force", "Force overwrite existing files without prompts").action((opts) => compileCommand(opts));
 program.command("validate").description("Validate PromptScript files").option("--strict", "Treat warnings as errors").option("--format <format>", "Output format (text, json)", "text").action(validateCommand);
 program.command("pull").description("Pull updates from registry").option("-f, --force", "Force overwrite").option("--dry-run", "Preview changes without pulling").option("-b, --branch <name>", "Git branch to pull from").option("--tag <name>", "Git tag to pull from").option("--commit <hash>", "Git commit to pull from").option("--refresh", "Force re-fetch from remote (ignore cache)").action(pullCommand);
 program.command("diff").description("Show diff for compiled output").option("-t, --target <target>", "Specific target").option("-a, --all", "Show diff for all targets at once").option("--full", "Show full diff without truncation").option("--no-pager", "Disable pager output").option("--color", "Force colored output").option("--no-color", "Disable colored output").action(diffCommand);
-program.command("check").description("Check configuration and dependencies health").option("--fix", "Attempt to fix issues").action(checkCommand);
+program.command("check").description("Check configuration and dependencies health").action(checkCommand);
+program.command("update-check").description("Check for CLI updates").action(updateCheckCommand);
 function run(args = process.argv) {
   program.parse(args);
 }
@@ -18262,18 +19818,25 @@ export {
   ConsoleOutput,
   LogLevel,
   checkCommand,
+  checkForUpdates,
   compileCommand,
   createSpinner,
   diffCommand,
+  fetchLatestVersion,
   findConfigFile,
+  forceCheckForUpdates,
+  getCacheDir,
+  getCachePath,
   getContext,
   initCommand,
   isQuiet,
   isVerbose,
   loadConfig,
+  printUpdateNotification,
   pullCommand,
   run,
   setContext,
+  updateCheckCommand,
   validateCommand
 };
 /*! Bundled license information: