@contextforge/core 0.1.2 → 0.1.6

package/dist/index.js

@@ -144,6 +144,7 @@ async function detectProject(root) {
   const vitest = vitestConfig || hasPackage(packageJson, "vitest");
   const jest = jestConfig || hasPackage(packageJson, "jest");
   const playwright = playwrightConfig || hasPackage(packageJson, "@playwright/test") || hasPackage(packageJson, "playwright");
+  const supabase = hasPackage(packageJson, "@supabase/supabase-js") || hasPackage(packageJson, "@supabase/ssr") || hasPackage(packageJson, "@supabase/auth-helpers-nextjs");
   return {
     root: resolvedRoot,
     packageManager,
@@ -154,6 +155,9 @@ async function detectProject(root) {
       shadcn
     },
     database,
+    services: {
+      supabase
+    },
     testing: {
       vitest,
       jest,
@@ -165,43 +169,71 @@ async function detectProject(root) {
 
 // src/registry/registrySchema.ts
 import { z } from "zod";
-var PackSchema = z.object({
+var PackFileTypeSchema = z.enum([
+  "rules",
+  "agents",
+  "claude",
+  "skill",
+  "cursor",
+  "copilot"
+]);
+var RegistryPackSourceSchema = z.object({
+  provider: z.string().optional(),
+  license: z.string().optional()
+}).catchall(z.unknown()).optional();
+var RegistryPackSummarySchema = z.object({
   name: z.string().min(1),
+  title: z.string().min(1),
+  topic: z.string().min(1),
+  description: z.string().default(""),
+  path: z.string().min(1),
+  source: RegistryPackSourceSchema
+});
+var RegistryIndexSchema = z.object({
+  name: z.string().optional(),
   version: z.string().optional(),
+  schemaVersion: z.string().optional(),
+  description: z.string().optional(),
+  topics: z.array(z.string()).default([]),
+  packs: z.array(RegistryPackSummarySchema)
+});
+var PackFileSchema = z.object({
+  type: PackFileTypeSchema,
+  path: z.string().min(1),
+  output: z.string().optional(),
+  mode: z.string().optional()
+});
+var PackOutputsSchema = z.object({
+  globalRules: z.boolean().optional(),
+  agentsInstruction: z.boolean().optional(),
+  claudeInstruction: z.boolean().optional(),
+  skill: z.boolean().optional(),
+  cursorRule: z.boolean().optional(),
+  copilotInstruction: z.boolean().optional()
+}).default({}).transform((outputs) => ({
+  globalRules: outputs.globalRules ?? true,
+  agentsInstruction: outputs.agentsInstruction ?? true,
+  claudeInstruction: outputs.claudeInstruction ?? true,
+  skill: outputs.skill ?? true,
+  cursorRule: outputs.cursorRule ?? true,
+  copilotInstruction: outputs.copilotInstruction ?? true
+}));
+var PackManifestSchema = z.object({
+  name: z.string().min(1),
   title: z.string().min(1),
-  description: z.string().min(1),
-  category: z.enum(["framework", "database", "testing", "security", "ui", "workflow"]),
+  version: z.string().default("0.0.0"),
+  topic: z.string().min(1),
+  description: z.string().default(""),
+  classification: z.enum(["always-referenced", "task-triggered", "permission-gated"]).default("task-triggered"),
+  source: RegistryPackSourceSchema,
   detect: z.object({
     files: z.array(z.string()).optional(),
     packages: z.array(z.string()).optional()
   }).optional(),
-  outputs: z.object({
-    globalRules: z.boolean().default(true),
-    skill: z.boolean().default(false),
-    cursorRule: z.boolean().default(true),
-    copilotInstruction: z.boolean().default(true)
-  })
-});
-var RemotePackFilesSchema = z.object({
-  pack: z.string().optional(),
-  rules: z.string().optional(),
-  skill: z.string().optional(),
-  cursor: z.string().optional(),
-  copilot: z.string().optional()
-});
-var RemotePackEntrySchema = z.object({
-  name: z.string().min(1),
-  version: z.string().optional(),
-  baseUrl: z.string().optional(),
-  pack: PackSchema.optional(),
-  files: RemotePackFilesSchema.optional()
-}).refine((entry) => Boolean(entry.baseUrl || entry.pack || entry.files?.pack), {
-  message: "Remote pack entry must include baseUrl, inline pack metadata, or files.pack"
-});
-var RemoteRegistryIndexSchema = z.object({
-  version: z.string().default("1"),
-  packs: z.array(RemotePackEntrySchema)
+  files: z.array(PackFileSchema).default([]),
+  outputs: PackOutputsSchema
 });
+var PackSchema = PackManifestSchema;
 
 // src/registry/loadRegistry.ts
 import path8 from "path";
@@ -209,117 +241,103 @@ import path8 from "path";
 // src/registry/localRegistry.ts
 import path7 from "path";
 import fs7 from "fs-extra";
-async function loadLocalRegistry(registryRoot, source) {
-  if (!await fs7.pathExists(registryRoot)) {
+async function readOptional(filePath) {
+  return await fs7.pathExists(filePath) ? fs7.readFile(filePath, "utf8") : void 0;
+}
+function normalizePackFilePath(file) {
+  return file.path.split(/[\\/]/u).join(path7.sep);
+}
+async function loadCachedPack(packRoot2) {
+  const manifestPath = path7.join(packRoot2, "pack.json");
+  if (!await fs7.pathExists(manifestPath)) {
+    return null;
+  }
+  const manifest = PackManifestSchema.parse(await fs7.readJson(manifestPath));
+  const files = {};
+  for (const file of manifest.files) {
+    const content = await readOptional(path7.join(packRoot2, normalizePackFilePath(file)));
+    if (content !== void 0) {
+      files[file.type] = content;
+    }
+  }
+  return {
+    manifest,
+    files
+  };
+}
+async function loadCachedPacks(packsRoot) {
+  if (!await fs7.pathExists(packsRoot)) {
     return [];
   }
-  const entries = await fs7.readdir(registryRoot, { withFileTypes: true });
+  const entries = await fs7.readdir(packsRoot, { withFileTypes: true });
   const packs = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const directory = path7.join(registryRoot, entry.name);
-    const packPath = path7.join(directory, "pack.json");
-    if (!await fs7.pathExists(packPath)) {
-      continue;
-    }
-    const parsed = PackSchema.parse(await fs7.readJson(packPath));
-    const readOptional = async (fileName) => {
-      const filePath = path7.join(directory, fileName);
-      return await fs7.pathExists(filePath) ? fs7.readFile(filePath, "utf8") : void 0;
-    };
-    const rules = await readOptional("rules.md");
-    if (!rules) {
-      throw new Error(`Pack "${parsed.name}" is missing rules.md`);
+    const pack = await loadCachedPack(path7.join(packsRoot, entry.name));
+    if (pack) {
+      packs.push(pack);
     }
-    packs.push({
-      ...parsed,
-      directory,
-      source,
-      files: {
-        rules,
-        skill: await readOptional("skill.md"),
-        cursor: await readOptional("cursor.mdc"),
-        copilot: await readOptional("copilot.md")
-      }
-    });
   }
-  return packs;
+  return packs.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
 }
 
 // src/registry/remoteRegistry.ts
 var DEFAULT_TIMEOUT_MS = 1e4;
-async function fetchText(url, required, timeoutMs) {
+async function fetchText(url, timeoutMs = DEFAULT_TIMEOUT_MS) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const response = await fetch(url, { signal: controller.signal });
     if (!response.ok) {
-      if (!required && response.status === 404) {
-        return void 0;
-      }
       throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
     }
     return response.text();
-  } catch (error) {
-    if (!required) {
-      return void 0;
-    }
-    throw error;
   } finally {
     clearTimeout(timeout);
   }
 }
-function resolveUrl(value, baseUrl) {
-  return value ? new URL(value, baseUrl).toString() : void 0;
+function resolvePackUrl(registryUrl, packPath) {
+  return new URL(packPath, registryUrl).toString();
 }
-function defaultPackFile(baseUrl, fileName) {
-  return baseUrl ? new URL(fileName, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString() : void 0;
+function resolvePackFileUrl(packUrl, filePath) {
+  return new URL(filePath, packUrl).toString();
 }
-async function loadRemoteRegistry(registryUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  const indexText = await fetchText(registryUrl, true, timeoutMs);
-  const index = RemoteRegistryIndexSchema.parse(JSON.parse(indexText ?? "{}"));
-  const packs = [];
-  for (const entry of index.packs) {
-    const baseUrl = resolveUrl(entry.baseUrl, registryUrl);
-    const packUrl = resolveUrl(entry.files?.pack, registryUrl) ?? defaultPackFile(baseUrl, "pack.json");
-    const rawPack = entry.pack ?? (packUrl ? JSON.parse(await fetchText(packUrl, true, timeoutMs) ?? "{}") : void 0);
-    const parsed = PackSchema.parse({
-      ...rawPack,
-      name: rawPack?.name ?? entry.name,
-      version: rawPack?.version ?? entry.version
-    });
-    const rulesUrl = resolveUrl(entry.files?.rules, registryUrl) ?? defaultPackFile(baseUrl, "rules.md");
-    if (!rulesUrl) {
-      throw new Error(`Remote pack "${entry.name}" is missing a rules.md URL.`);
-    }
-    packs.push({
-      ...parsed,
-      directory: baseUrl ?? registryUrl,
-      source: "remote",
-      registryUrl,
-      files: {
-        rules: await fetchText(rulesUrl, true, timeoutMs) ?? "",
-        skill: await fetchText(
-          resolveUrl(entry.files?.skill, registryUrl) ?? defaultPackFile(baseUrl, "skill.md") ?? "",
-          false,
-          timeoutMs
-        ),
-        cursor: await fetchText(
-          resolveUrl(entry.files?.cursor, registryUrl) ?? defaultPackFile(baseUrl, "cursor.mdc") ?? "",
-          false,
-          timeoutMs
-        ),
-        copilot: await fetchText(
-          resolveUrl(entry.files?.copilot, registryUrl) ?? defaultPackFile(baseUrl, "copilot.md") ?? "",
-          false,
-          timeoutMs
-        )
-      }
-    });
+async function fetchRegistry(registryUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const content = await fetchText(registryUrl, timeoutMs);
+  return RegistryIndexSchema.parse(JSON.parse(content));
+}
+async function fetchPackManifest(packUrl, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const content = await fetchText(packUrl, timeoutMs);
+  return PackManifestSchema.parse(JSON.parse(content));
+}
+function findPackSummary(registry, packName) {
+  return registry.packs.find((pack) => pack.name === packName);
+}
+async function fetchPackFile(packUrl, file, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return fetchText(resolvePackFileUrl(packUrl, file.path), timeoutMs);
+}
+function sortRegistryPacks(registry) {
+  return [...registry.packs].sort((a, b) => a.topic.localeCompare(b.topic) || a.name.localeCompare(b.name));
+}
+function listRegistryPacks(input) {
+  if (typeof input === "string") {
+    return fetchRegistry(input).then(sortRegistryPacks);
+  }
+  return sortRegistryPacks(input);
+}
+function searchRegistryPacks(input, query) {
+  if (typeof input === "string") {
+    return fetchRegistry(input).then((registry) => searchRegistryPacks(registry, query));
+  }
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return sortRegistryPacks(input);
   }
-  return packs;
+  return sortRegistryPacks(input).filter(
+    (pack) => [pack.name, pack.title, pack.description, pack.topic].join(" ").toLowerCase().includes(normalized)
+  );
 }
 
 // src/registry/loadRegistry.ts
@@ -327,56 +345,99 @@ var OFFICIAL_REGISTRY_SOURCE = "official";
 var OFFICIAL_REGISTRY_URL = "https://registry.contextforge.org/index.json";
 var DEFAULT_REGISTRY_SOURCES = [OFFICIAL_REGISTRY_SOURCE];
 var PROJECT_PACK_CACHE = ".contextforge/packs";
-function mergePacks(packs) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const pack of packs) {
-    if (!byName.has(pack.name)) {
-      byName.set(pack.name, pack);
-    }
-  }
-  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-async function loadRegistrySource(source, timeoutMs) {
-  if (source === OFFICIAL_REGISTRY_SOURCE) {
-    try {
-      return await loadRemoteRegistry(OFFICIAL_REGISTRY_URL, timeoutMs ?? 1500);
-    } catch {
-      return [];
-    }
-  }
-  return loadRemoteRegistry(source, timeoutMs);
+function sourceToUrl(source) {
+  return source === OFFICIAL_REGISTRY_SOURCE ? OFFICIAL_REGISTRY_URL : source;
 }
 async function loadRegistry(input = {}) {
   if (typeof input === "string") {
-    return mergePacks(await loadLocalRegistry(input, "local"));
-  }
-  const sources = input.sources ?? DEFAULT_REGISTRY_SOURCES;
-  const packs = [];
-  if (input.root) {
-    packs.push(...await loadLocalRegistry(path8.join(input.root, PROJECT_PACK_CACHE), "project-cache"));
+    return fetchRegistry(input);
   }
-  for (const source of sources) {
-    packs.push(...await loadRegistrySource(source, input.timeoutMs));
-  }
-  return mergePacks(packs);
+  const source = input.sources?.[0] ?? OFFICIAL_REGISTRY_SOURCE;
+  return fetchRegistry(sourceToUrl(source), input.timeoutMs);
+}
+function registrySourceToUrl(source) {
+  return sourceToUrl(source ?? OFFICIAL_REGISTRY_SOURCE);
+}
+async function loadRemotePack(registryUrl, summary, timeoutMs) {
+  const packUrl = resolvePackUrl(registryUrl, summary.path);
+  const manifest = await fetchPackManifest(packUrl, timeoutMs);
+  return {
+    manifest,
+    summary,
+    packUrl,
+    files: {}
+  };
+}
+async function loadProjectPacks(root) {
+  return loadCachedPacks(path8.join(root, PROJECT_PACK_CACHE));
 }
 
 // src/registry/resolvePack.ts
 import path9 from "path";
 import fg5 from "fast-glob";
 import fs8 from "fs-extra";
+
+// src/config/configSchema.ts
+import { z as z2 } from "zod";
+var ToolSchema = z2.enum(["codex", "claude", "cursor", "copilot"]);
+var DEFAULT_TOOLS = ["codex", "claude", "cursor", "copilot"];
+var DEFAULT_CORE_PACKS = [
+  "verification-before-completion",
+  "systematic-debugging",
+  "code-review",
+  "git-workflow",
+  "dependency-management",
+  "diataxis-docs"
+];
+var CurrentConfigSchema = z2.object({
+  version: z2.string().default("0.1.0"),
+  registry: z2.string().default(OFFICIAL_REGISTRY_URL),
+  tools: z2.array(ToolSchema).default(DEFAULT_TOOLS),
+  installedPacks: z2.array(z2.string()).default([]),
+  defaultCorePacks: z2.array(z2.string()).default([...DEFAULT_CORE_PACKS]),
+  generatedFiles: z2.array(z2.string()).default([])
+});
+var LegacyConfigSchema = z2.object({
+  version: z2.string().optional(),
+  registries: z2.array(z2.string()).optional(),
+  tools: z2.array(ToolSchema).optional(),
+  packs: z2.array(z2.string()).optional(),
+  packageManager: z2.string().optional(),
+  generatedFiles: z2.array(z2.string()).optional()
+});
+function normalizeConfig(raw) {
+  const current = CurrentConfigSchema.safeParse(raw);
+  if (current.success && "installedPacks" in raw) {
+    return current.data;
+  }
+  const legacy = LegacyConfigSchema.safeParse(raw);
+  if (legacy.success) {
+    return CurrentConfigSchema.parse({
+      version: legacy.data.version ?? "0.1.0",
+      registry: legacy.data.registries?.find((source) => source !== "official") ?? OFFICIAL_REGISTRY_URL,
+      tools: legacy.data.tools ?? DEFAULT_TOOLS,
+      installedPacks: legacy.data.packs ?? [],
+      defaultCorePacks: [...DEFAULT_CORE_PACKS],
+      generatedFiles: legacy.data.generatedFiles ?? []
+    });
+  }
+  return CurrentConfigSchema.parse(raw);
+}
+var ConfigSchema = {
+  parse: normalizeConfig
+};
+
+// src/registry/resolvePack.ts
 function findPack(registry, packName) {
-  return registry.find((pack) => pack.name === packName);
+  return registry.packs.find((pack) => pack.name === packName);
 }
-function resolvePacks(packNames, registry) {
-  const uniqueNames = [...new Set(packNames)];
-  return uniqueNames.map((packName) => {
-    const pack = findPack(registry, packName);
-    if (!pack) {
-      throw new Error(`Unknown ContextForge pack: ${packName}`);
-    }
-    return pack;
-  });
+function mandatoryCorePacks(registry) {
+  return DEFAULT_CORE_PACKS.map((name) => findPack(registry, name)).filter(
+    (pack) => Boolean(pack)
+  );
+}
+function missingMandatoryCorePacks(registry) {
+  return DEFAULT_CORE_PACKS.filter((name) => !findPack(registry, name));
 }
 async function hasDetectFile(root, filePattern) {
   if (filePattern.includes("*")) {
@@ -389,31 +450,40 @@ async function hasDetectFile(root, filePattern) {
   }
   return fs8.pathExists(path9.join(root, filePattern));
 }
-function hasDetectHints(pack) {
-  return Boolean(pack.detect?.files?.length || pack.detect?.packages?.length);
-}
-async function recommendPacks(analysis, registry) {
-  const packageJson = await readPackageJson(analysis.root);
-  const recommended = [];
-  for (const pack of registry) {
-    if (pack.name === "env-secrets") {
-      recommended.push(pack);
-      continue;
-    }
-    if (hasDetectHints(pack) && await packMatchesProject(pack, analysis.root, packageJson)) {
-      recommended.push(pack);
-    }
-  }
-  return recommended;
-}
-async function packMatchesProject(pack, root, packageJson) {
+async function manifestMatchesProject(manifest, root, packageJson) {
   const fileChecks = await Promise.all(
-    pack.detect?.files?.map((filePattern) => hasDetectFile(root, filePattern)) ?? []
+    manifest.detect?.files?.map((filePattern) => hasDetectFile(root, filePattern)) ?? []
   );
-  const packageChecks = pack.detect?.packages?.map((packageName) => hasPackage(packageJson, packageName)) ?? [];
+  const packageChecks = manifest.detect?.packages?.map((packageName) => hasPackage(packageJson, packageName)) ?? [];
   const checks = [...fileChecks, ...packageChecks];
   return checks.length === 0 || checks.some(Boolean);
 }
+function recommendPackNames(analysis) {
+  const names = /* @__PURE__ */ new Set();
+  if (analysis.framework === "next-app-router") {
+    names.add("nextjs-best-practices");
+    names.add("react-performance");
+    names.add("react-composition");
+  }
+  if (analysis.styling.tailwind || analysis.styling.shadcn) {
+    names.add("shadcn-ui");
+    names.add("tailwind-v4");
+    names.add("ui-ux-design");
+    names.add("frontend-aesthetics");
+  }
+  if (analysis.language === "typescript") {
+    names.add("typescript-advanced-types");
+  }
+  if (analysis.services.supabase) {
+    names.add("supabase");
+    names.add("security-baseline");
+  }
+  return [...names];
+}
+async function recommendPacks(analysis, registry) {
+  const recommendedNames = recommendPackNames(analysis);
+  return recommendedNames.map((name) => findPack(registry, name)).filter((pack) => Boolean(pack));
+}
 function packageManagerLabel(packageManager) {
   const labels = {
     pnpm: "pnpm",
@@ -424,169 +494,167 @@ function packageManagerLabel(packageManager) {
   };
   return labels[packageManager];
 }
-
-// src/config/configSchema.ts
-import { z as z2 } from "zod";
-var ToolSchema = z2.enum(["codex", "claude", "cursor", "copilot"]);
-var ConfigSchema = z2.object({
-  version: z2.string().default("0.1.0"),
-  registries: z2.array(z2.string()).default(DEFAULT_REGISTRY_SOURCES),
-  tools: z2.array(ToolSchema).default(["codex", "claude", "cursor", "copilot"]),
-  packs: z2.array(z2.string()).default([]),
-  packageManager: z2.enum(["pnpm", "npm", "yarn", "bun", "unknown"]).default("unknown"),
-  generatedFiles: z2.array(z2.string()).default([])
-});
+async function packMatchesProject(pack, root, packageJson) {
+  return manifestMatchesProject(pack.manifest, root, packageJson ?? await readPackageJson(root));
+}
+function resolvePacks(packNames, packs) {
+  return packNames.map((packName) => {
+    const pack = packs.find((item) => item.manifest.name === packName);
+    if (!pack) {
+      throw new Error(`Unknown ContextForge pack: ${packName}`);
+    }
+    return pack;
+  });
+}
 
 // src/config/defaultConfig.ts
-var DEFAULT_TOOLS = ["codex", "claude", "cursor", "copilot"];
-function createConfig(analysis, packs, tools = DEFAULT_TOOLS, registries = DEFAULT_REGISTRY_SOURCES) {
+function createConfig(_analysis, packs, tools = DEFAULT_TOOLS, registry = OFFICIAL_REGISTRY_URL) {
   return {
     version: "0.1.0",
-    registries,
+    registry,
     tools,
-    packs: packs.map((pack) => pack.name),
-    packageManager: analysis.packageManager,
+    installedPacks: [...new Set(packs.map((pack) => pack.name))],
+    defaultCorePacks: [...DEFAULT_CORE_PACKS],
     generatedFiles: []
   };
 }
 
-// src/config/loadConfig.ts
+// src/config/lockFile.ts
 import path10 from "path";
 import fs9 from "fs-extra";
+import { z as z3 } from "zod";
+var LOCK_PATH = ".contextforge/lock.json";
+var LockSchema = z3.object({
+  registry: z3.string(),
+  resolvedAt: z3.string(),
+  packs: z3.record(
+    z3.string(),
+    z3.object({
+      version: z3.string(),
+      path: z3.string(),
+      source: z3.string()
+    })
+  )
+});
+async function loadLock(root) {
+  const lockPath = path10.join(root, LOCK_PATH);
+  if (!await fs9.pathExists(lockPath)) {
+    return null;
+  }
+  return LockSchema.parse(await fs9.readJson(lockPath));
+}
+async function saveLock(root, lock) {
+  const lockPath = path10.join(root, LOCK_PATH);
+  await fs9.ensureDir(path10.dirname(lockPath));
+  await fs9.writeFile(lockPath, `${JSON.stringify(lock, null, 2)}
+`);
+}
+async function updateContextForgeLock(root, registry, installed) {
+  const lock = {
+    registry,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    packs: {}
+  };
+  for (const pack of installed) {
+    lock.packs[pack.manifest.name] = {
+      version: pack.manifest.version,
+      path: pack.summary?.path ?? `packs/${pack.manifest.name}/pack.json`,
+      source: pack.packUrl ?? ""
+    };
+  }
+  await saveLock(root, lock);
+  return lock;
+}
+
+// src/config/loadConfig.ts
+import path11 from "path";
+import fs10 from "fs-extra";
 var CONFIG_PATH = ".contextforge/config.json";
 async function loadConfig(root) {
-  const configPath = path10.join(root, CONFIG_PATH);
-  if (!await fs9.pathExists(configPath)) {
+  const configPath = path11.join(root, CONFIG_PATH);
+  if (!await fs10.pathExists(configPath)) {
     throw new Error("ContextForge config not found. Run `npx @contextforge/cli init` first.");
   }
-  return ConfigSchema.parse(await fs9.readJson(configPath));
+  return ConfigSchema.parse(await fs10.readJson(configPath));
 }
 
 // src/config/saveConfig.ts
-import path11 from "path";
-import fs10 from "fs-extra";
+import path12 from "path";
+import fs11 from "fs-extra";
 async function saveConfig(root, config) {
-  const configPath = path11.join(root, CONFIG_PATH);
-  await fs10.ensureDir(path11.dirname(configPath));
-  await fs10.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+  const configPath = path12.join(root, CONFIG_PATH);
+  await fs11.ensureDir(path12.dirname(configPath));
+  await fs11.writeFile(configPath, `${JSON.stringify(config, null, 2)}
 `);
 }
 function addPackToConfig(config, packName) {
   return {
     ...config,
-    packs: [.../* @__PURE__ */ new Set([...config.packs, packName])]
+    installedPacks: [.../* @__PURE__ */ new Set([...config.installedPacks, packName])]
   };
 }
 
 // src/registry/installPacks.ts
-import path12 from "path";
-import fs11 from "fs-extra";
-var INSTALLED_PACKS_PATH = ".contextforge/installed-packs.json";
-function packJson(pack) {
-  return {
-    name: pack.name,
-    version: pack.version,
-    title: pack.title,
-    description: pack.description,
-    category: pack.category,
-    detect: pack.detect,
-    outputs: pack.outputs
-  };
+import path13 from "path";
+import fs12 from "fs-extra";
+function normalizeRelativePath(relativePath) {
+  return relativePath.split(/[\\/]/u).join(path13.sep);
+}
+function packRoot(projectRoot, packName) {
+  return path13.join(projectRoot, PROJECT_PACK_CACHE, packName);
 }
-async function writePack(root, pack) {
-  const packRoot = path12.join(root, PROJECT_PACK_CACHE, pack.name);
-  await fs11.ensureDir(packRoot);
-  await fs11.writeFile(path12.join(packRoot, "pack.json"), `${JSON.stringify(packJson(pack), null, 2)}
+function packFilePath(projectRoot, packName, file) {
+  return path13.join(packRoot(projectRoot, packName), normalizeRelativePath(file.path));
+}
+async function downloadPackToContextForge(projectRoot, packName, packManifest, packUrl, timeoutMs) {
+  const root = packRoot(projectRoot, packName);
+  const files = {};
+  await fs12.ensureDir(root);
+  await fs12.writeFile(path13.join(root, "pack.json"), `${JSON.stringify(packManifest, null, 2)}
 `);
-  await fs11.writeFile(path12.join(packRoot, "rules.md"), pack.files.rules);
-  const optionalFiles = [
-    ["skill.md", pack.files.skill],
-    ["cursor.mdc", pack.files.cursor],
-    ["copilot.md", pack.files.copilot]
-  ];
-  for (const [fileName, content] of optionalFiles) {
-    if (content) {
-      await fs11.writeFile(path12.join(packRoot, fileName), content);
-    }
+  for (const file of packManifest.files) {
+    const content = await fetchPackFile(packUrl, file, timeoutMs);
+    const targetPath = packFilePath(projectRoot, packName, file);
+    await fs12.ensureDir(path13.dirname(targetPath));
+    await fs12.writeFile(targetPath, content);
+    files[file.type] = content;
   }
+  return {
+    manifest: packManifest,
+    packUrl,
+    files
+  };
 }
-async function cacheRemotePacks(root, packs) {
-  for (const pack of packs) {
-    if (pack.source === "remote") {
-      await writePack(root, pack);
-    }
+async function installPack(projectRoot, registryUrl, packName, options = {}) {
+  const registry = await fetchRegistry(registryUrl, options.timeoutMs);
+  const summary = findPackSummary(registry, packName);
+  if (!summary) {
+    throw new Error(`Unknown ContextForge pack: ${packName}`);
   }
-}
-async function saveInstalledPacks(root, packs) {
-  const metadataPath = path12.join(root, INSTALLED_PACKS_PATH);
-  const metadata = {
-    version: "1",
-    packs: packs.map((pack) => ({
-      name: pack.name,
-      version: pack.version ?? "0.0.0",
-      source: pack.source,
-      registryUrl: pack.registryUrl
-    }))
+  const alreadyInstalled = await fs12.pathExists(path13.join(packRoot(projectRoot, packName), "pack.json"));
+  const packUrl = resolvePackUrl(registryUrl, summary.path);
+  const manifest = await fetchPackManifest(packUrl, options.timeoutMs);
+  if (alreadyInstalled && !options.force) {
+    return {
+      installed: false,
+      alreadyInstalled: true,
+      packName,
+      manifest,
+      summary,
+      packUrl
+    };
+  }
+  if (!options.dryRun) {
+    await downloadPackToContextForge(projectRoot, packName, manifest, packUrl, options.timeoutMs);
+  }
+  return {
+    installed: !options.dryRun,
+    alreadyInstalled,
+    packName,
+    manifest,
+    summary,
+    packUrl
   };
-  await fs11.ensureDir(path12.dirname(metadataPath));
-  await fs11.writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}
-`);
-}
-
-// src/compiler/compileAgentsMd.ts
-function compileAgentsMd(analysis, packs) {
-  return [
-    "# ContextForge Instructions",
-    "",
-    "Generated by ContextForge. Add project-specific guidance outside this block.",
-    "",
-    "## Detected Project",
-    `- Framework: ${analysis.framework}`,
-    `- Language: ${analysis.language}`,
-    `- Package manager: ${packageManagerLabel(analysis.packageManager)}`,
-    `- Styling: ${analysis.styling.tailwind ? "Tailwind CSS" : "not detected"}${analysis.styling.shadcn ? " + shadcn/ui" : ""}`,
-    `- Database: ${analysis.database.prisma ? "Prisma" : analysis.database.drizzle ? "Drizzle" : "not detected"}`,
-    `- Testing: ${[
-      analysis.testing.vitest && "Vitest",
-      analysis.testing.jest && "Jest",
-      analysis.testing.playwright && "Playwright"
-    ].filter(Boolean).join(", ") || "not detected"}`,
-    "",
-    "## Active Packs",
-    ...packs.flatMap((pack) => [
-      "",
-      `### ${pack.title}`,
-      "",
-      pack.description,
-      "",
-      pack.files.rules.trim()
-    ])
-  ].join("\n");
-}
-
-// src/compiler/compileClaudeMd.ts
-function compileClaudeMd(analysis, packs) {
-  return compileAgentsMd(analysis, packs).replace(
-    "# ContextForge Instructions",
-    "# ContextForge Claude Instructions"
-  );
-}
-
-// src/compiler/compileCopilotInstructions.ts
-function compileCopilotInstructions(analysis, packs) {
-  const enabledPacks = packs.filter((pack) => pack.outputs.copilotInstruction);
-  return [
-    "# ContextForge Copilot Instructions",
-    "",
-    `Project framework: ${analysis.framework}. Language: ${analysis.language}.`,
-    "",
-    ...enabledPacks.flatMap((pack) => [
-      `## ${pack.title}`,
-      "",
-      (pack.files.copilot ?? pack.files.rules).trim(),
-      ""
-    ])
-  ].join("\n");
 }
 
 // src/fs/updateGeneratedBlock.ts
@@ -602,6 +670,9 @@ function escapeRegExp(value) {
 function getGeneratedBlock(content) {
   return content.match(blockPattern)?.[0] ?? null;
 }
+function removeGeneratedBlock(content) {
+  return content.replace(blockPattern, "").replace(/\s+$/u, "");
+}
 function wrapGeneratedBlock(content) {
   return `${GENERATED_BLOCK_START}
 ${content.trim()}
@@ -624,151 +695,470 @@ ${generatedBlock}
 `;
 }
 
-// src/compiler/compileCursorRules.ts
-function withCursorFrontmatter(description, content) {
+// src/compiler/compileOutputs.ts
+function normalizeOutputPath(outputPath) {
+  return outputPath.split(/[\\/]/u).join("/");
+}
+function defaultOutput(packName, type) {
+  const defaults = {
+    rules: null,
+    agents: `.contextforge/agents/codex/${packName}.md`,
+    claude: `.contextforge/agents/claude/${packName}.md`,
+    skill: `.contextforge/skills/${packName}/SKILL.md`,
+    cursor: `.contextforge/agents/cursor/${packName}.md`,
+    copilot: `.contextforge/agents/copilot/${packName}.md`
+  };
+  return defaults[type];
+}
+function shouldGenerateFile(type, tools) {
+  if (type === "agents") {
+    return tools.includes("codex");
+  }
+  if (type === "claude") {
+    return tools.includes("claude");
+  }
+  if (type === "skill") {
+    return tools.length > 0;
+  }
+  if (type === "cursor") {
+    return tools.includes("cursor");
+  }
+  if (type === "copilot") {
+    return tools.includes("copilot");
+  }
+  return false;
+}
+function compileRootAgents(packs, analysis) {
   return [
-    "---",
-    `description: ${description}`,
-    "alwaysApply: true",
-    "---",
+    "# Project Agent Instructions",
     "",
     GENERATED_BLOCK_START,
-    content.trim(),
+    "ContextForge is installed for this repo.",
+    "",
+    "Before working, read the relevant instruction files in:",
+    "",
+    "- `.contextforge/agents/codex/`",
+    "- `.contextforge/skills/`",
+    "",
+    "Follow the installed packs listed in `.contextforge/config.json`.",
+    "Do not copy these instructions into this file.",
     GENERATED_BLOCK_END
   ].join("\n");
 }
-function compileCursorRules(analysis, packs) {
-  const files = [
-    {
-      path: ".cursor/rules/contextforge.mdc",
-      content: withCursorFrontmatter(
-        "ContextForge generated project overview",
-        [
-          "# ContextForge Project Context",
-          "",
-          `- Framework: ${analysis.framework}`,
-          `- Language: ${analysis.language}`,
-          `- Package manager: ${analysis.packageManager}`,
-          `- Active packs: ${packs.map((pack) => pack.name).join(", ") || "none"}`
-        ].join("\n")
-      )
-    }
-  ];
-  for (const pack of packs.filter((item) => item.outputs.cursorRule)) {
-    files.push({
-      path: `.cursor/rules/${pack.name}.mdc`,
-      content: withCursorFrontmatter(
-        pack.description.replace(/:/g, "-"),
-        (pack.files.cursor ?? pack.files.rules).trim()
-      )
-    });
-  }
-  return files;
-}
-
-// src/compiler/compileSkills.ts
-function escapeYaml(value) {
-  return value.replace(/"/g, '\\"');
-}
-function compileSkills(packs) {
-  return packs.filter((pack) => pack.outputs.skill).map((pack) => ({
-    path: `.agents/skills/${pack.name}/SKILL.md`,
-    content: [
-      "---",
-      `name: ${pack.name}`,
-      `description: "${escapeYaml(pack.description)}"`,
-      "---",
-      "",
-      GENERATED_BLOCK_START,
-      (pack.files.skill ?? pack.files.rules).trim(),
-      GENERATED_BLOCK_END
-    ].join("\n")
-  }));
+function compileRootClaude(packs) {
+  return [
+    "# Claude Code Instructions",
+    "",
+    GENERATED_BLOCK_START,
+    "ContextForge is installed for this repo.",
+    "",
+    "Before working, read the relevant instruction files in:",
+    "",
+    "- `.contextforge/agents/claude/`",
+    "- `.contextforge/skills/`",
+    "",
+    "Follow the installed packs listed in `.contextforge/config.json`.",
+    "Do not copy these instructions into this file.",
+    GENERATED_BLOCK_END
+  ].join("\n");
 }
-
-// src/compiler/compileOutputs.ts
 function compileOutputs(config, packs, analysis) {
   const outputs = [];
+  for (const pack of packs) {
+    for (const file of pack.manifest.files) {
+      if (!shouldGenerateFile(file.type, config.tools)) {
+        continue;
+      }
+      const content = pack.files[file.type];
+      const outputPath = defaultOutput(pack.manifest.name, file.type);
+      if (!content || !outputPath) {
+        continue;
+      }
+      outputs.push({
+        path: normalizeOutputPath(outputPath),
+        content: withContextForgePreamble(pack, file.type, content)
+      });
+    }
+  }
   if (config.tools.includes("codex")) {
-    outputs.push({ path: "AGENTS.md", content: compileAgentsMd(analysis, packs) });
-    outputs.push(...compileSkills(packs));
+    outputs.push({ path: "AGENTS.md", content: compileRootAgents(packs, analysis) });
   }
   if (config.tools.includes("claude")) {
-    outputs.push({ path: "CLAUDE.md", content: compileClaudeMd(analysis, packs) });
+    outputs.push({ path: "CLAUDE.md", content: compileRootClaude(packs) });
   }
-  if (config.tools.includes("cursor")) {
-    outputs.push(...compileCursorRules(analysis, packs));
+  return outputs;
+}
+function withContextForgePreamble(pack, type, content) {
+  if (pack.manifest.name !== "git-workflow" || !["agents", "claude", "cursor", "copilot"].includes(type)) {
+    return content;
   }
-  if (config.tools.includes("copilot")) {
-    outputs.push({
-      path: ".github/copilot-instructions.md",
-      content: compileCopilotInstructions(analysis, packs)
-    });
+  const warning = "Do not commit, push, merge, rebase, reset, delete branches, or rewrite history unless explicitly requested by the user.";
+  if (content.includes(warning)) {
+    return content;
   }
-  return outputs;
+  return ["# ContextForge Git Safety", "", warning, "", content.trim()].join("\n");
 }
 
-// src/compiler/writeGeneratedFiles.ts
-import path14 from "path";
+// src/compiler/compileAgentsMd.ts
+async function compileAgentsMd() {
+  return [
+    "# Project Agent Instructions",
+    "",
+    GENERATED_BLOCK_START,
+    "ContextForge is installed for this repo.",
+    "",
+    "Before working, read the relevant instruction files in:",
+    "",
+    "- `.contextforge/agents/codex/`",
+    "- `.contextforge/skills/`",
+    "",
+    "Follow the installed packs listed in `.contextforge/config.json`.",
+    "Do not copy these instructions into this file.",
+    GENERATED_BLOCK_END
+  ].join("\n");
+}
+
+// src/compiler/compileClaudeMd.ts
+async function compileClaudeMd() {
+  return [
+    "# Claude Code Instructions",
+    "",
+    GENERATED_BLOCK_START,
+    "ContextForge is installed for this repo.",
+    "",
+    "Before working, read the relevant instruction files in:",
+    "",
+    "- `.contextforge/agents/claude/`",
+    "- `.contextforge/skills/`",
+    "",
+    "Follow the installed packs listed in `.contextforge/config.json`.",
+    "Do not copy these instructions into this file.",
+    GENERATED_BLOCK_END
+  ].join("\n");
+}
+
+// src/compiler/generateToolOutputs.ts
+import path16 from "path";
+import fs15 from "fs-extra";
 
 // src/fs/safeWriteFile.ts
-import path13 from "path";
-import fs12 from "fs-extra";
+import path14 from "path";
+import fs13 from "fs-extra";
 async function safeWriteFile(filePath, generatedContent) {
-  const existingContent = await fs12.pathExists(filePath) ? await fs12.readFile(filePath, "utf8") : null;
+  const existingContent = await fs13.pathExists(filePath) ? await fs13.readFile(filePath, "utf8") : null;
   const nextContent = updateGeneratedBlock(existingContent, generatedContent);
-  await fs12.ensureDir(path13.dirname(filePath));
-  await fs12.writeFile(filePath, nextContent);
+  await fs13.ensureDir(path14.dirname(filePath));
+  await fs13.writeFile(filePath, nextContent);
+}
+
+// src/compiler/cleanupGeneratedFiles.ts
+import path15 from "path";
+import fs14 from "fs-extra";
+function isGeneratedOnlyPath(relativePath) {
+  return relativePath.startsWith(".agents/skills/") || relativePath.startsWith(".cursor/rules/") || relativePath.startsWith(".github/instructions/") || relativePath.startsWith(".contextforge/instructions/") || relativePath.startsWith(".contextforge/agents/") || relativePath.startsWith(".contextforge/skills/");
+}
+async function cleanupFile(root, relativePath) {
+  const filePath = path15.join(root, relativePath);
+  if (!await fs14.pathExists(filePath)) {
+    return;
+  }
+  if (isGeneratedOnlyPath(relativePath)) {
+    await fs14.remove(filePath);
+    return;
+  }
+  const content = await fs14.readFile(filePath, "utf8");
+  if (!getGeneratedBlock(content)) {
+    return;
+  }
+  const nextContent = removeGeneratedBlock(content);
+  if (nextContent.trim().length === 0) {
+    await fs14.remove(filePath);
+    return;
+  }
+  await fs14.writeFile(filePath, `${nextContent}
+`);
+}
+async function cleanupStaleGeneratedFiles(root, previousFiles, currentFiles) {
+  const current = new Set(currentFiles);
+  const staleFiles = [...new Set(previousFiles)].filter((file) => !current.has(file));
+  for (const staleFile of staleFiles) {
+    await cleanupFile(root, staleFile);
+  }
+}
+
+// src/compiler/generateToolOutputs.ts
+var GENERATED_ONLY_PREFIXES = [
+  ".contextforge/agents/",
+  ".contextforge/skills/"
+];
+function normalizeOutputPath2(outputPath) {
+  return outputPath.split(/[\\/]/u).join("/");
+}
+function defaultOutput2(packName, type) {
+  const defaults = {
+    rules: null,
+    agents: `.contextforge/agents/codex/${packName}.md`,
+    claude: `.contextforge/agents/claude/${packName}.md`,
+    skill: `.contextforge/skills/${packName}/SKILL.md`,
+    cursor: `.contextforge/agents/cursor/${packName}.md`,
+    copilot: `.contextforge/agents/copilot/${packName}.md`
+  };
+  return defaults[type];
+}
+function shouldGenerateFile2(type, tools) {
+  if (type === "agents") {
+    return tools.includes("codex");
+  }
+  if (type === "claude") {
+    return tools.includes("claude");
+  }
+  if (type === "skill") {
+    return tools.length > 0;
+  }
+  if (type === "cursor") {
+    return tools.includes("cursor");
+  }
+  if (type === "copilot") {
+    return tools.includes("copilot");
+  }
+  return false;
+}
+function generatedFileFromPack(pack, file) {
+  const content = pack.files[file.type];
+  const outputPath = defaultOutput2(pack.manifest.name, file.type);
+  if (!content || !outputPath) {
+    return null;
+  }
+  return {
+    path: normalizeOutputPath2(outputPath),
+    content: withContextForgePreamble2(pack, file.type, content)
+  };
+}
+function withContextForgePreamble2(pack, type, content) {
+  if (pack.manifest.name !== "git-workflow" || !["agents", "claude", "cursor", "copilot"].includes(type)) {
+    return content;
+  }
+  const warning = "Do not commit, push, merge, rebase, reset, delete branches, or rewrite history unless explicitly requested by the user.";
+  if (content.includes(warning)) {
+    return content;
+  }
+  return ["# ContextForge Git Safety", "", warning, "", content.trim()].join("\n");
+}
+async function writeGeneratedOnlyFile(root, output) {
+  const filePath = path16.join(root, output.path);
+  await fs15.ensureDir(path16.dirname(filePath));
+  await fs15.writeFile(filePath, output.content.endsWith("\n") ? output.content : `${output.content}
+`);
+}
+function packOutputs(pack, tools) {
+  return pack.manifest.files.filter((file) => shouldGenerateFile2(file.type, tools)).map((file) => generatedFileFromPack(pack, file)).filter((file) => Boolean(file));
+}
+async function generateToolOutputs(root, packs, config, previousFiles = []) {
+  const packGeneratedOutputs = packs.flatMap((pack) => packOutputs(pack, config.tools));
+  for (const output of packGeneratedOutputs) {
+    const isGeneratedOnly = GENERATED_ONLY_PREFIXES.some((prefix) => output.path.startsWith(prefix));
+    if (isGeneratedOnly) {
+      await writeGeneratedOnlyFile(root, output);
+    } else {
+      await safeWriteFile(path16.join(root, output.path), output.content);
+    }
+  }
+  const rootOutputs = [];
+  if (config.tools.includes("codex")) {
+    rootOutputs.push({ path: "AGENTS.md", content: await compileAgentsMd() });
+  }
+  if (config.tools.includes("claude")) {
+    rootOutputs.push({ path: "CLAUDE.md", content: await compileClaudeMd() });
+  }
+  for (const output of rootOutputs) {
+    await safeWriteFile(path16.join(root, output.path), output.content);
+  }
+  const currentFiles = [...packGeneratedOutputs, ...rootOutputs].map((output) => output.path);
+  await cleanupStaleGeneratedFiles(root, previousFiles, currentFiles);
+  return currentFiles;
 }
 
 // src/compiler/writeGeneratedFiles.ts
-async function writeGeneratedFiles(root, outputs) {
+import path17 from "path";
+async function writeGeneratedFiles(root, outputs, previousFiles = []) {
+  const currentFiles = outputs.map((output) => output.path);
   for (const output of outputs) {
-    await safeWriteFile(path14.join(root, output.path), output.content);
+    await safeWriteFile(path17.join(root, output.path), output.content);
   }
-  return outputs.map((output) => output.path);
+  await cleanupStaleGeneratedFiles(root, previousFiles, currentFiles);
+  return currentFiles;
 }
 
 // src/sync.ts
-import path15 from "path";
-async function syncProject(root, providedConfig) {
-  const resolvedRoot = path15.resolve(root);
-  const analysis = await detectProject(resolvedRoot);
-  const config = providedConfig ?? await loadConfig(resolvedRoot);
-  const registry = await loadRegistry({
-    root: resolvedRoot,
-    sources: config.registries
-  });
-  const packs = resolvePacks(config.packs, registry);
-  await cacheRemotePacks(resolvedRoot, packs);
-  await saveInstalledPacks(resolvedRoot, packs);
-  const outputs = compileOutputs(config, packs, analysis);
-  const generatedFiles = await writeGeneratedFiles(resolvedRoot, outputs);
+import path18 from "path";
+import fs16 from "fs-extra";
+async function updateContextForgeConfig(projectRoot, packName, registryUrl, generatedFiles) {
+  const existing = await loadOptionalConfig(projectRoot);
+  const config = addPackToConfig(
+    existing ?? {
+      version: "0.1.0",
+      registry: registryUrl,
+      tools: ["codex", "claude", "cursor", "copilot"],
+      installedPacks: [],
+      defaultCorePacks: [],
+      generatedFiles: []
+    },
+    packName
+  );
   const nextConfig = {
     ...config,
-    packageManager: config.packageManager === "unknown" ? analysis.packageManager : config.packageManager,
+    registry: registryUrl,
     generatedFiles
   };
-  await saveConfig(resolvedRoot, nextConfig);
+  await saveConfig(projectRoot, nextConfig);
+  return nextConfig;
+}
+async function loadOptionalConfig(root) {
+  try {
+    return await loadConfig(root);
+  } catch {
+    return null;
+  }
+}
+async function loadInstalledPackFromRegistry(projectRoot, registryUrl, summary, timeoutMs) {
+  const packUrl = resolvePackUrl(registryUrl, summary.path);
+  const manifest = await fetchPackManifest(packUrl, timeoutMs);
+  return downloadPackToContextForge(projectRoot, manifest.name, manifest, packUrl, timeoutMs);
+}
+async function syncInstalledPacks(projectRoot, providedConfig) {
+  const root = path18.resolve(projectRoot);
+  const analysis = await detectProject(root);
+  const previousConfig = await loadOptionalConfig(root);
+  const config = providedConfig ?? await loadConfig(root);
+  const registry = await fetchRegistry(config.registry);
+  const installed = [];
+  const missing = [];
+  for (const packName of config.installedPacks) {
+    const summary = findPackSummary(registry, packName);
+    if (!summary) {
+      missing.push(packName);
+      continue;
+    }
+    installed.push(await loadInstalledPackFromRegistry(root, config.registry, summary));
+  }
+  const generatedFiles = await generateToolOutputs(
+    root,
+    installed,
+    config,
+    previousConfig?.generatedFiles ?? []
+  );
+  const nextConfig = {
+    ...config,
+    installedPacks: installed.map((pack) => pack.manifest.name),
+    generatedFiles
+  };
+  await saveConfig(root, nextConfig);
+  await updateContextForgeLock(
+    root,
+    config.registry,
+    installed.map((pack) => ({
+      manifest: pack.manifest,
+      summary: registry.packs.find((summary) => summary.name === pack.manifest.name),
+      packUrl: pack.packUrl
+    }))
+  );
+  if (missing.length > 0) {
+    throw new Error(`Installed packs missing from registry: ${missing.join(", ")}`);
+  }
   return {
-    root: resolvedRoot,
+    root,
     analysis,
     generatedFiles,
-    outputs,
-    config: nextConfig
+    outputs: generatedFiles.map((file) => ({ path: file, content: "" })),
+    config: nextConfig,
+    installedPacks: installed
+  };
+}
+async function syncProject(root, providedConfig) {
+  return syncInstalledPacks(root, providedConfig);
+}
+async function installPackAndSync(projectRoot, registryUrl, packName, options = {}) {
+  const root = path18.resolve(projectRoot);
+  const config = await loadOptionalConfig(root);
+  const result = await installPack(root, registryUrl, packName, options);
+  if (result.alreadyInstalled && !options.force && config?.installedPacks.includes(packName)) {
+    return {
+      ...result,
+      generatedFiles: [],
+      config: config ?? void 0
+    };
+  }
+  if (options.dryRun) {
+    return {
+      ...result,
+      generatedFiles: [],
+      config: config ?? void 0
+    };
+  }
+  const nextConfig = {
+    version: "0.1.0",
+    registry: registryUrl,
+    tools: options.tools ?? config?.tools ?? ["codex", "claude", "cursor", "copilot"],
+    installedPacks: [.../* @__PURE__ */ new Set([...config?.installedPacks ?? [], packName])],
+    defaultCorePacks: config?.defaultCorePacks ?? [],
+    generatedFiles: config?.generatedFiles ?? []
   };
+  const syncResult = await syncInstalledPacks(root, nextConfig);
+  return {
+    ...result,
+    generatedFiles: syncResult.generatedFiles,
+    config: syncResult.config
+  };
+}
+async function readInstalledPacks(projectRoot) {
+  return loadProjectPacks(projectRoot);
+}
+async function pathExists(root, relativePath) {
+  return fs16.pathExists(path18.join(root, relativePath));
 }
 
 // src/doctor/doctorProject.ts
-import path16 from "path";
-import fs13 from "fs-extra";
+import path19 from "path";
+import fs17 from "fs-extra";
 async function fileExists(root, relativePath) {
-  return fs13.pathExists(path16.join(root, relativePath));
+  return fs17.pathExists(path19.join(root, relativePath));
+}
+async function readIfExists(root, relativePath) {
+  const filePath = path19.join(root, relativePath);
+  if (!await fs17.pathExists(filePath)) {
+    return null;
+  }
+  return fs17.readFile(filePath, "utf8");
+}
+function hasContextForgeBlock(content) {
+  return Boolean(content && getGeneratedBlock(content));
+}
+function tooLarge(content) {
+  return Boolean(content && content.length > 2e4);
+}
+function expectedGeneratedOutputs(packName, tools) {
+  const outputs = [];
+  if (tools.length > 0) {
+    outputs.push(`.contextforge/skills/${packName}/SKILL.md`);
+  }
+  if (tools.includes("codex")) {
+    outputs.push(`.contextforge/agents/codex/${packName}.md`);
+  }
+  if (tools.includes("claude")) {
+    outputs.push(`.contextforge/agents/claude/${packName}.md`);
+  }
+  if (tools.includes("cursor")) {
+    outputs.push(`.contextforge/agents/cursor/${packName}.md`);
+  }
+  if (tools.includes("copilot")) {
+    outputs.push(`.contextforge/agents/copilot/${packName}.md`);
+  }
+  return outputs;
 }
-async function doctorProject(root) {
+async function doctorProject(root, options = {}) {
   const checks = [];
   const issues = [];
-  const resolvedRoot = path16.resolve(root);
+  const resolvedRoot = path19.resolve(root);
   if (!await fileExists(resolvedRoot, CONFIG_PATH)) {
     return {
       checks,
@@ -782,97 +1172,206 @@ async function doctorProject(root) {
   }
   checks.push("Config found");
   const config = await loadConfig(resolvedRoot);
-  const [analysis, registry, packageJson] = await Promise.all([
+  const registryUrl = options.registry ?? config.registry;
+  const [analysis, packageJson, lock] = await Promise.all([
     detectProject(resolvedRoot),
-    loadRegistry({ root: resolvedRoot, sources: config.registries }),
-    readPackageJson(resolvedRoot)
+    readPackageJson(resolvedRoot),
+    loadLock(resolvedRoot)
   ]);
-  const packs = resolvePacks(config.packs, registry);
-  const requiredFiles = [
-    [config.tools.includes("codex"), "AGENTS.md", "Codex instructions found"],
-    [config.tools.includes("claude"), "CLAUDE.md", "Claude instructions found"],
-    [config.tools.includes("cursor"), ".cursor/rules", "Cursor rules found"],
-    [config.tools.includes("copilot"), ".github/copilot-instructions.md", "Copilot instructions found"]
-  ];
-  for (const [enabled, relativePath, okMessage] of requiredFiles) {
-    if (!enabled) {
+  let registryPacks = /* @__PURE__ */ new Set();
+  try {
+    const registry = await fetchRegistry(registryUrl);
+    registryPacks = new Set(registry.packs.map((pack) => pack.name));
+    checks.push("Registry reachable");
+  } catch (error) {
+    issues.push({
+      level: "error",
+      message: `Registry ${registryUrl} is not reachable: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  if (lock) {
+    checks.push("Lock file found");
+  } else {
+    issues.push({
+      level: "warning",
+      message: `${LOCK_PATH} is missing. Run \`npx @contextforge/cli sync\`.`
+    });
+  }
+  const cachedPacks = await loadProjectPacks(resolvedRoot);
+  const cachedPackNames = new Set(cachedPacks.map((pack) => pack.manifest.name));
+  for (const packName of config.installedPacks) {
+    if (registryPacks.size > 0 && !registryPacks.has(packName)) {
+      issues.push({
+        level: "error",
+        message: `${packName} is installed in config, but no longer exists in the registry.`
+      });
+    }
+    if (!cachedPackNames.has(packName)) {
+      issues.push({
+        level: "error",
+        message: `.contextforge/packs/${packName}/pack.json is missing. Run \`npx @contextforge/cli sync\`.`
+      });
       continue;
     }
-    if (await fileExists(resolvedRoot, relativePath)) {
-      checks.push(okMessage);
+    for (const output of expectedGeneratedOutputs(packName, config.tools)) {
+      if (!await fileExists(resolvedRoot, output)) {
+        issues.push({
+          level: "error",
+          message: `${output} is missing. Run \`npx @contextforge/cli sync\`.`
+        });
+      }
+    }
+  }
+  const agentsMd = await readIfExists(resolvedRoot, "AGENTS.md");
+  const claudeMd = await readIfExists(resolvedRoot, "CLAUDE.md");
+  if (config.tools.includes("codex")) {
+    if (hasContextForgeBlock(agentsMd)) {
+      checks.push("AGENTS.md ContextForge block found");
+    } else {
+      issues.push({
+        level: "error",
+        message: "AGENTS.md is missing a ContextForge generated block. Run `npx @contextforge/cli sync`."
+      });
+    }
+  }
+  if (config.tools.includes("claude")) {
+    if (hasContextForgeBlock(claudeMd)) {
+      checks.push("CLAUDE.md ContextForge block found");
     } else {
       issues.push({
         level: "error",
-        message: `${relativePath} is missing. Run \`npx @contextforge/cli sync\`.`
+        message: "CLAUDE.md is missing a ContextForge generated block. Run `npx @contextforge/cli sync`."
       });
     }
   }
-  for (const generatedFile of config.generatedFiles) {
-    if (!await fileExists(resolvedRoot, generatedFile)) {
+  if (tooLarge(agentsMd)) {
+    issues.push({
+      level: "warning",
+      message: "AGENTS.md is large. Root instructions should stay concise; detailed content belongs in pack files and skills."
+    });
+  }
+  if (tooLarge(claudeMd)) {
+    issues.push({
+      level: "warning",
+      message: "CLAUDE.md is large. Root instructions should stay concise; detailed content belongs in pack files."
+    });
+  }
+  const gitWorkflow = cachedPacks.find((pack) => pack.manifest.name === "git-workflow");
+  if (gitWorkflow) {
+    const generatedGitFiles = await Promise.all(
+      ["codex", "claude", "cursor", "copilot"].map(
+        (tool) => readIfExists(resolvedRoot, `.contextforge/agents/${tool}/git-workflow.md`)
+      )
+    );
+    const gitSummary = [
+      gitWorkflow.files.agents,
+      gitWorkflow.files.claude,
+      ...generatedGitFiles,
+      agentsMd,
+      claudeMd
+    ].filter((content) => Boolean(content)).join("\n").toLowerCase();
+    if (!gitSummary.includes("do not commit") || !gitSummary.includes("push") || !gitSummary.includes("explicitly")) {
       issues.push({
         level: "warning",
-        message: `Previously generated file ${generatedFile} is missing.`
+        message: "git-workflow is installed, but the expected explicit-permission git safety warning was not found."
       });
     }
   }
-  for (const pack of packs) {
+  for (const pack of cachedPacks) {
     if (!await packMatchesProject(pack, resolvedRoot, packageJson)) {
       issues.push({
         level: "warning",
-        message: `${pack.name} pack is installed, but its detection hints do not match this project.`
+        message: `${pack.manifest.name} is installed, but its detection hints do not match this project.`
       });
     }
   }
-  if (config.packageManager !== "unknown" && analysis.packageManager !== "unknown" && config.packageManager !== analysis.packageManager) {
+  if (config.installedPacks.includes("test-driven-development") && !hasScript(packageJson, "test")) {
     issues.push({
       level: "warning",
-      message: `Config says package manager is ${config.packageManager}, but ${analysis.packageManager} was detected.`
+      message: "test-driven-development is installed, but package.json has no test script."
     });
   }
-  if (config.packs.includes("testing-workflow") && !hasScript(packageJson, "test")) {
-    issues.push({
-      level: "warning",
-      message: "testing-workflow is installed, but package.json has no test script."
-    });
+  for (const recommendedPack of recommendPackNames(analysis)) {
+    if (!config.installedPacks.includes(recommendedPack) && registryPacks.has(recommendedPack)) {
+      issues.push({
+        level: "warning",
+        message: `${recommendedPack} matches the detected stack but is not installed. Run \`npx @contextforge/cli add ${recommendedPack}\` if you want it.`
+      });
+    }
   }
   return { checks, issues };
 }
 export {
   CONFIG_PATH,
   ConfigSchema,
+  DEFAULT_CORE_PACKS,
   DEFAULT_REGISTRY_SOURCES,
   DEFAULT_TOOLS,
   GENERATED_BLOCK_END,
   GENERATED_BLOCK_START,
+  LOCK_PATH,
   OFFICIAL_REGISTRY_SOURCE,
   OFFICIAL_REGISTRY_URL,
   PROJECT_PACK_CACHE,
+  PackFileSchema,
+  PackFileTypeSchema,
+  PackManifestSchema,
   PackSchema,
-  RemotePackEntrySchema,
-  RemotePackFilesSchema,
-  RemoteRegistryIndexSchema,
+  RegistryIndexSchema,
+  RegistryPackSourceSchema,
+  RegistryPackSummarySchema,
+  ToolSchema,
   addPackToConfig,
-  cacheRemotePacks,
+  compileAgentsMd,
+  compileClaudeMd,
   compileOutputs,
   createConfig,
   detectPackageManager,
   detectProject,
   doctorProject,
+  downloadPackToContextForge,
+  fetchPackFile,
+  fetchPackManifest,
+  fetchRegistry,
+  fetchText,
   findPack,
+  findPackSummary,
+  generateToolOutputs,
   getGeneratedBlock,
   hasPackage,
   hasScript,
+  installPack,
+  installPackAndSync,
+  listRegistryPacks,
   loadConfig,
+  loadLock,
+  loadProjectPacks,
   loadRegistry,
+  loadRemotePack,
+  mandatoryCorePacks,
+  manifestMatchesProject,
+  missingMandatoryCorePacks,
+  normalizeConfig,
   packMatchesProject,
   packageManagerLabel,
+  pathExists,
+  readInstalledPacks,
   readPackageJson,
+  recommendPackNames,
   recommendPacks,
+  registrySourceToUrl,
+  removeGeneratedBlock,
+  resolvePackFileUrl,
+  resolvePackUrl,
   resolvePacks,
   safeWriteFile,
   saveConfig,
-  saveInstalledPacks,
+  saveLock,
+  searchRegistryPacks,
+  syncInstalledPacks,
   syncProject,
+  updateContextForgeConfig,
+  updateContextForgeLock,
   updateGeneratedBlock,
   wrapGeneratedBlock,
   writeGeneratedFiles