@fractary/codex-cli 0.2.2 → 0.4.0

package/dist/cli.cjs

@@ -2,12 +2,12 @@
 'use strict';
 
 var fs = require('fs/promises');
-var path2 = require('path');
+var path3 = require('path');
 var yaml = require('js-yaml');
 var codex = require('@fractary/codex');
 var commander = require('commander');
-var chalk6 = require('chalk');
-var child_process = require('child_process');
+var chalk8 = require('chalk');
+var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -30,9 +30,10 @@ function _interopNamespace(e) {
 }
 
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
 var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
-var chalk6__default = /*#__PURE__*/_interopDefault(chalk6);
+var chalk8__default = /*#__PURE__*/_interopDefault(chalk8);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -89,7 +90,7 @@ async function migrateConfig(legacyConfigPath, options) {
       organization: legacy.organization || legacy.organizationSlug || "default"
     };
     if (legacy.cache) {
-      yamlConfig.cacheDir = legacy.cache.directory || ".codex-cache";
+      yamlConfig.cacheDir = legacy.cache.directory || ".fractary/codex/cache";
     }
     if (legacy.storage?.providers) {
       yamlConfig.storage = [];
@@ -185,7 +186,7 @@ async function migrateConfig(legacyConfigPath, options) {
   }
 }
 async function writeYamlConfig(config, outputPath) {
-  const dir = path2__namespace.dirname(outputPath);
+  const dir = path3__namespace.dirname(outputPath);
   await fs__namespace.mkdir(dir, { recursive: true });
   const yamlContent = yaml__namespace.dump(config, {
     indent: 2,
@@ -198,7 +199,7 @@ async function writeYamlConfig(config, outputPath) {
 function getDefaultYamlConfig(organization) {
   return {
     organization,
-    cacheDir: ".codex-cache",
+    cacheDir: ".fractary/codex/cache",
     storage: [
       {
         type: "local",
@@ -409,7 +410,7 @@ var init_codex_client = __esm({
         const { readYamlConfig: readYamlConfig2 } = await Promise.resolve().then(() => (init_migrate_config(), migrate_config_exports));
         const { resolveEnvVarsInConfig: resolveEnvVarsInConfig2 } = await Promise.resolve().then(() => (init_config_types(), config_types_exports));
         try {
-          const configPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
+          const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex.yaml");
           let config;
           try {
             config = await readYamlConfig2(configPath);
@@ -621,13 +622,110 @@ var init_codex_client = __esm({
 // src/cli.ts
 init_cjs_shims();
 
-// src/commands/init.ts
+// src/commands/document/index.ts
+init_cjs_shims();
+
+// src/commands/document/fetch.ts
+init_cjs_shims();
+
+// src/client/get-client.ts
+init_cjs_shims();
+var clientInstance = null;
+async function getClient(options) {
+  if (!clientInstance) {
+    const { CodexClient: CodexClient2 } = await Promise.resolve().then(() => (init_codex_client(), codex_client_exports));
+    clientInstance = await CodexClient2.create(options);
+  }
+  return clientInstance;
+}
+
+// src/commands/document/fetch.ts
+function hashContent(content) {
+  return crypto__namespace.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function fetchCommand() {
+  const cmd = new commander.Command("fetch");
+  cmd.description("Fetch a document by codex:// URI reference").argument("<uri>", "Codex URI (e.g., codex://org/project/docs/file.md)").option("--bypass-cache", "Skip cache and fetch directly from source").option("--ttl <seconds>", "Override default TTL (in seconds)", parseInt).option("--json", "Output as JSON with metadata").option("--output <file>", "Write content to file instead of stdout").action(async (uri, options) => {
+    try {
+      const { validateUri } = await import('@fractary/codex');
+      if (!validateUri(uri)) {
+        console.error(chalk8__default.default.red("Error: Invalid URI format"));
+        console.log(chalk8__default.default.dim("Expected: codex://org/project/path/to/file.md"));
+        console.log(chalk8__default.default.dim("Example: codex://fractary/codex/docs/api.md"));
+        process.exit(1);
+      }
+      const client = await getClient();
+      if (!options.json && !options.bypassCache) {
+        console.error(chalk8__default.default.dim(`Fetching ${uri}...`));
+      }
+      const result = await client.fetch(uri, {
+        bypassCache: options.bypassCache,
+        ttl: options.ttl
+      });
+      if (options.json) {
+        const output = {
+          uri,
+          content: result.content.toString("utf-8"),
+          metadata: {
+            fromCache: result.fromCache,
+            fetchedAt: result.metadata?.fetchedAt,
+            expiresAt: result.metadata?.expiresAt,
+            contentLength: result.metadata?.contentLength || result.content.length,
+            contentHash: hashContent(result.content)
+          }
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else if (options.output) {
+        await fs__namespace.writeFile(options.output, result.content);
+        console.log(chalk8__default.default.green("\u2713"), `Written to ${options.output}`);
+        console.log(chalk8__default.default.dim(`  Size: ${result.content.length} bytes`));
+        if (result.fromCache) {
+          console.log(chalk8__default.default.dim("  Source: cache"));
+        } else {
+          console.log(chalk8__default.default.dim("  Source: storage"));
+        }
+      } else {
+        if (result.fromCache && !options.bypassCache) {
+          console.error(chalk8__default.default.green("\u2713"), chalk8__default.default.dim("from cache\n"));
+        } else {
+          console.error(chalk8__default.default.green("\u2713"), chalk8__default.default.dim("fetched\n"));
+        }
+        console.log(result.content.toString("utf-8"));
+      }
+    } catch (error) {
+      console.error(chalk8__default.default.red("Error:"), error.message);
+      if (error.message.includes("Failed to load configuration")) {
+        console.log(chalk8__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
+      } else if (error.message.includes("GITHUB_TOKEN")) {
+        console.log(chalk8__default.default.dim('\nSet your GitHub token: export GITHUB_TOKEN="your_token"'));
+      } else if (error.message.includes("not found") || error.message.includes("404")) {
+        console.log(chalk8__default.default.dim("\nThe document may not exist or you may not have access."));
+        console.log(chalk8__default.default.dim("Check the URI and ensure your storage providers are configured correctly."));
+      }
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/document/index.ts
+function documentCommand() {
+  const cmd = new commander.Command("document");
+  cmd.description("Manage document operations");
+  cmd.addCommand(fetchCommand());
+  return cmd;
+}
+
+// src/commands/config/index.ts
+init_cjs_shims();
+
+// src/commands/config/init.ts
 init_cjs_shims();
 init_migrate_config();
 async function getOrgFromGitRemote() {
   try {
-    const { execSync: execSync2 } = __require("child_process");
-    const remote = execSync2("git remote get-url origin 2>/dev/null", { encoding: "utf-8" }).trim();
+    const { execSync } = __require("child_process");
+    const remote = execSync("git remote get-url origin 2>/dev/null", { encoding: "utf-8" }).trim();
     const sshMatch = remote.match(/git@github\.com:([^/]+)\//);
     const httpsMatch = remote.match(/github\.com\/([^/]+)\//);
     return sshMatch?.[1] || httpsMatch?.[1] || null;
@@ -647,7 +745,7 @@ function initCommand() {
   const cmd = new commander.Command("init");
   cmd.description("Initialize Codex v3.0 with YAML configuration").option("--org <slug>", 'Organization slug (e.g., "fractary")').option("--mcp", "Enable MCP server registration").option("--force", "Overwrite existing configuration").action(async (options) => {
     try {
-      console.log(chalk6__default.default.blue("Initializing Codex v3.0 (YAML format)...\n"));
+      console.log(chalk8__default.default.blue("Initializing Codex v3.0 (YAML format)...\n"));
       let org = options.org;
       if (!org) {
         org = await getOrgFromGitRemote();
@@ -656,41 +754,35 @@ function initCommand() {
         try {
           const { resolveOrganization } = await import('@fractary/codex');
           org = resolveOrganization({
-            repoName: path2__namespace.basename(process.cwd())
+            repoName: path3__namespace.basename(process.cwd())
           });
         } catch {
         }
       }
       if (!org) {
-        org = path2__namespace.basename(process.cwd()).split("-")[0] || "default";
-        console.log(chalk6__default.default.yellow(`\u26A0 Could not detect organization, using: ${org}`));
-        console.log(chalk6__default.default.dim("  Use --org <slug> to specify explicitly\n"));
+        org = path3__namespace.basename(process.cwd()).split("-")[0] || "default";
+        console.log(chalk8__default.default.yellow(`\u26A0 Could not detect organization, using: ${org}`));
+        console.log(chalk8__default.default.dim("  Use --org <slug> to specify explicitly\n"));
       } else {
-        console.log(chalk6__default.default.dim(`Organization: ${chalk6__default.default.cyan(org)}
+        console.log(chalk8__default.default.dim(`Organization: ${chalk8__default.default.cyan(org)}
 `));
       }
-      const configDir = path2__namespace.join(process.cwd(), ".fractary");
-      const configPath = path2__namespace.join(configDir, "codex.yaml");
+      const configDir = path3__namespace.join(process.cwd(), ".fractary", "codex");
+      const configPath = path3__namespace.join(configDir, "config.yaml");
       const configExists = await fileExists(configPath);
-      const legacyConfigPath = path2__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
-      const legacyExists = await fileExists(legacyConfigPath);
       if (configExists && !options.force) {
-        console.log(chalk6__default.default.yellow("\u26A0 Configuration already exists at .fractary/codex.yaml"));
-        console.log(chalk6__default.default.dim("Use --force to overwrite"));
+        console.log(chalk8__default.default.yellow("\u26A0 Configuration already exists at .fractary/codex/config.yaml"));
+        console.log(chalk8__default.default.dim("Use --force to overwrite"));
         process.exit(1);
       }
-      if (legacyExists && !configExists) {
-        console.log(chalk6__default.default.yellow("\u26A0 Legacy configuration detected at .fractary/plugins/codex/config.json"));
-        console.log(chalk6__default.default.dim('Run "fractary codex migrate" to upgrade to YAML format\n'));
-      }
       console.log("Creating directory structure...");
       const dirs = [
-        ".fractary",
-        ".codex-cache"
+        ".fractary/codex",
+        ".fractary/codex/cache"
       ];
       for (const dir of dirs) {
-        await fs__namespace.mkdir(path2__namespace.join(process.cwd(), dir), { recursive: true });
-        console.log(chalk6__default.default.green("\u2713"), chalk6__default.default.dim(dir + "/"));
+        await fs__namespace.mkdir(path3__namespace.join(process.cwd(), dir), { recursive: true });
+        console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(dir + "/"));
       }
       console.log("\nCreating YAML configuration...");
       const config = getDefaultYamlConfig(org);
@@ -698,113 +790,179 @@ function initCommand() {
         config.mcp.enabled = true;
       }
       await writeYamlConfig(config, configPath);
-      console.log(chalk6__default.default.green("\u2713"), chalk6__default.default.dim(".fractary/codex.yaml"));
-      console.log(chalk6__default.default.green("\n\u2713 Codex v3.0 initialized successfully!\n"));
-      console.log(chalk6__default.default.bold("Configuration:"));
-      console.log(chalk6__default.default.dim(`  Organization: ${org}`));
-      console.log(chalk6__default.default.dim(`  Cache: .codex-cache/`));
-      console.log(chalk6__default.default.dim(`  Config: .fractary/codex.yaml`));
+      console.log(chalk8__default.default.green("\u2713"), chalk8__default.default.dim(".fractary/codex/config.yaml"));
+      console.log(chalk8__default.default.green("\n\u2713 Codex v4.0 initialized successfully!\n"));
+      console.log(chalk8__default.default.bold("Configuration:"));
+      console.log(chalk8__default.default.dim(`  Organization: ${org}`));
+      console.log(chalk8__default.default.dim(`  Cache: .fractary/codex/cache/`));
+      console.log(chalk8__default.default.dim(`  Config: .fractary/codex/config.yaml`));
       if (options.mcp) {
-        console.log(chalk6__default.default.dim(`  MCP Server: Enabled (port 3000)`));
-      }
-      console.log(chalk6__default.default.bold("\nStorage providers configured:"));
-      console.log(chalk6__default.default.dim("  - Local filesystem (./knowledge)"));
-      console.log(chalk6__default.default.dim("  - GitHub (requires GITHUB_TOKEN)"));
-      console.log(chalk6__default.default.dim("  - HTTP endpoint"));
-      console.log(chalk6__default.default.bold("\nNext steps:"));
-      console.log(chalk6__default.default.dim('  1. Set your GitHub token: export GITHUB_TOKEN="your_token"'));
-      console.log(chalk6__default.default.dim("  2. Edit .fractary/codex.yaml to configure storage providers"));
-      console.log(chalk6__default.default.dim("  3. Fetch a document: fractary codex fetch codex://org/project/path"));
-      console.log(chalk6__default.default.dim("  4. Check cache: fractary codex cache list"));
-      if (legacyExists) {
-        console.log(chalk6__default.default.yellow("\n\u26A0 Legacy config detected:"));
-        console.log(chalk6__default.default.dim('  Run "fractary codex migrate" to convert your existing config'));
-      }
+        console.log(chalk8__default.default.dim(`  MCP Server: Enabled (port 3000)`));
+      }
+      console.log(chalk8__default.default.bold("\nStorage providers configured:"));
+      console.log(chalk8__default.default.dim("  - Local filesystem (./knowledge)"));
+      console.log(chalk8__default.default.dim("  - GitHub (requires GITHUB_TOKEN)"));
+      console.log(chalk8__default.default.dim("  - HTTP endpoint"));
+      console.log(chalk8__default.default.bold("\nNext steps:"));
+      console.log(chalk8__default.default.dim('  1. Set your GitHub token: export GITHUB_TOKEN="your_token"'));
+      console.log(chalk8__default.default.dim("  2. Edit .fractary/codex/config.yaml to configure storage providers"));
+      console.log(chalk8__default.default.dim("  3. Fetch a document: fractary codex fetch codex://org/project/path"));
+      console.log(chalk8__default.default.dim("  4. Check cache: fractary codex cache list"));
     } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
+      console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
   return cmd;
 }
 
-// src/commands/fetch.ts
-init_cjs_shims();
-
-// src/client/get-client.ts
+// src/commands/config/migrate.ts
 init_cjs_shims();
-var clientInstance = null;
-async function getClient(options) {
-  if (!clientInstance) {
-    const { CodexClient: CodexClient2 } = await Promise.resolve().then(() => (init_codex_client(), codex_client_exports));
-    clientInstance = await CodexClient2.create(options);
+init_migrate_config();
+async function fileExists2(filePath) {
+  try {
+    await fs__namespace.access(filePath);
+    return true;
+  } catch {
+    return false;
   }
-  return clientInstance;
 }
-
-// src/commands/fetch.ts
-function hashContent(content) {
-  const crypto = __require("crypto");
-  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+async function readFileContent(filePath) {
+  return fs__namespace.readFile(filePath, "utf-8");
 }
-function fetchCommand() {
-  const cmd = new commander.Command("fetch");
-  cmd.description("Fetch a document by codex:// URI reference").argument("<uri>", "Codex URI (e.g., codex://org/project/docs/file.md)").option("--bypass-cache", "Skip cache and fetch directly from source").option("--ttl <seconds>", "Override default TTL (in seconds)", parseInt).option("--json", "Output as JSON with metadata").option("--output <file>", "Write content to file instead of stdout").action(async (uri, options) => {
+function migrateCommand() {
+  const cmd = new commander.Command("migrate");
+  cmd.description("Migrate legacy JSON configuration to v3.0 YAML format").option("--dry-run", "Show migration plan without executing").option("--no-backup", "Skip creating backup of old config").option("--json", "Output as JSON").action(async (options) => {
     try {
-      const { validateUri } = await import('@fractary/codex');
-      if (!validateUri(uri)) {
-        console.error(chalk6__default.default.red("Error: Invalid URI format"));
-        console.log(chalk6__default.default.dim("Expected: codex://org/project/path/to/file.md"));
-        console.log(chalk6__default.default.dim("Example: codex://fractary/codex/docs/api.md"));
+      const legacyConfigPath = path3__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
+      const newConfigPath = path3__namespace.join(process.cwd(), ".fractary", "codex.yaml");
+      if (!await fileExists2(legacyConfigPath)) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            status: "no_config",
+            message: "No legacy configuration file found",
+            path: legacyConfigPath
+          }));
+        } else {
+          console.log(chalk8__default.default.yellow("\u26A0 No legacy configuration file found."));
+          console.log(chalk8__default.default.dim(`  Expected: ${legacyConfigPath}`));
+          console.log(chalk8__default.default.dim('\nRun "fractary codex init" to create a new v3.0 YAML configuration.'));
+        }
+        return;
+      }
+      if (await fileExists2(newConfigPath) && !options.dryRun) {
+        if (options.json) {
+          console.log(JSON.stringify({
+            status: "already_migrated",
+            message: "YAML configuration already exists",
+            path: newConfigPath
+          }));
+        } else {
+          console.log(chalk8__default.default.yellow("\u26A0 YAML configuration already exists."));
+          console.log(chalk8__default.default.dim(`  Path: ${newConfigPath}`));
+          console.log(chalk8__default.default.dim('\nUse "fractary codex init --force" to recreate.'));
+        }
+        return;
+      }
+      const legacyContent = await readFileContent(legacyConfigPath);
+      let legacyConfig;
+      try {
+        legacyConfig = JSON.parse(legacyContent);
+      } catch {
+        console.error(chalk8__default.default.red("Error:"), "Invalid JSON in legacy config file.");
         process.exit(1);
       }
-      const client = await getClient();
-      if (!options.json && !options.bypassCache) {
-        console.error(chalk6__default.default.dim(`Fetching ${uri}...`));
+      if (!options.json && !options.dryRun) {
+        console.log(chalk8__default.default.blue("Migrating Codex configuration to v3.0 YAML format...\n"));
+      }
+      const migrationResult = await migrateConfig(
+        legacyConfigPath,
+        {
+          createBackup: options.backup !== false,
+          backupSuffix: (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")
+        }
+      );
+      if (!options.json) {
+        console.log(chalk8__default.default.bold("Legacy Configuration:"));
+        console.log(chalk8__default.default.dim(`  Path: ${legacyConfigPath}`));
+        console.log(chalk8__default.default.dim(`  Organization: ${legacyConfig.organization || legacyConfig.organizationSlug || "unknown"}`));
+        console.log("");
+        console.log(chalk8__default.default.bold("Migration Changes:"));
+        console.log(chalk8__default.default.green("  + Format: JSON \u2192 YAML"));
+        console.log(chalk8__default.default.green("  + Location: .fractary/plugins/codex/ \u2192 .fractary/"));
+        console.log(chalk8__default.default.green("  + File: config.json \u2192 codex.yaml"));
+        console.log(chalk8__default.default.green("  + Storage: Multi-provider configuration"));
+        console.log(chalk8__default.default.green("  + Cache: Modern cache management"));
+        console.log(chalk8__default.default.green("  + Types: Custom type registry"));
+        if (migrationResult.warnings.length > 0) {
+          console.log("");
+          console.log(chalk8__default.default.yellow("Warnings:"));
+          for (const warning of migrationResult.warnings) {
+            console.log(chalk8__default.default.yellow("  \u26A0"), chalk8__default.default.dim(warning));
+          }
+        }
+        console.log("");
+        if (options.dryRun) {
+          console.log(chalk8__default.default.blue("Dry run - no changes made."));
+          console.log(chalk8__default.default.dim("Run without --dry-run to execute migration."));
+          return;
+        }
       }
-      const result = await client.fetch(uri, {
-        bypassCache: options.bypassCache,
-        ttl: options.ttl
-      });
       if (options.json) {
         const output = {
-          uri,
-          content: result.content.toString("utf-8"),
-          metadata: {
-            fromCache: result.fromCache,
-            fetchedAt: result.metadata?.fetchedAt,
-            expiresAt: result.metadata?.expiresAt,
-            contentLength: result.metadata?.contentLength || result.content.length,
-            contentHash: hashContent(result.content)
-          }
+          status: options.dryRun ? "migration_ready" : "migrated",
+          dryRun: options.dryRun || false,
+          legacyConfig: {
+            path: legacyConfigPath,
+            organization: legacyConfig.organization || legacyConfig.organizationSlug
+          },
+          newConfig: {
+            path: newConfigPath,
+            organization: migrationResult.yamlConfig.organization
+          },
+          warnings: migrationResult.warnings,
+          backupPath: migrationResult.backupPath
         };
         console.log(JSON.stringify(output, null, 2));
-      } else if (options.output) {
-        await fs__namespace.writeFile(options.output, result.content);
-        console.log(chalk6__default.default.green("\u2713"), `Written to ${options.output}`);
-        console.log(chalk6__default.default.dim(`  Size: ${result.content.length} bytes`));
-        if (result.fromCache) {
-          console.log(chalk6__default.default.dim("  Source: cache"));
-        } else {
-          console.log(chalk6__default.default.dim("  Source: storage"));
+        if (options.dryRun) {
+          return;
         }
-      } else {
-        if (result.fromCache && !options.bypassCache) {
-          console.error(chalk6__default.default.green("\u2713"), chalk6__default.default.dim("from cache\n"));
-        } else {
-          console.error(chalk6__default.default.green("\u2713"), chalk6__default.default.dim("fetched\n"));
+      }
+      if (!options.dryRun) {
+        await writeYamlConfig(migrationResult.yamlConfig, newConfigPath);
+        const cacheDir = path3__namespace.join(process.cwd(), ".codex-cache");
+        await fs__namespace.mkdir(cacheDir, { recursive: true });
+        if (!options.json) {
+          console.log(chalk8__default.default.green("\u2713"), "YAML configuration created");
+          console.log(chalk8__default.default.green("\u2713"), "Cache directory initialized");
+          if (migrationResult.backupPath) {
+            console.log(chalk8__default.default.green("\u2713"), "Legacy config backed up");
+          }
+          console.log("");
+          console.log(chalk8__default.default.bold("New Configuration:"));
+          console.log(chalk8__default.default.dim(`  Path: ${newConfigPath}`));
+          console.log(chalk8__default.default.dim(`  Organization: ${migrationResult.yamlConfig.organization}`));
+          console.log(chalk8__default.default.dim(`  Cache: ${migrationResult.yamlConfig.cacheDir || ".codex-cache"}`));
+          console.log(chalk8__default.default.dim(`  Storage Providers: ${migrationResult.yamlConfig.storage?.length || 0}`));
+          console.log("");
+          console.log(chalk8__default.default.bold("Next Steps:"));
+          console.log(chalk8__default.default.dim("  1. Review the new configuration: .fractary/codex.yaml"));
+          console.log(chalk8__default.default.dim('  2. Set your GitHub token: export GITHUB_TOKEN="your_token"'));
+          console.log(chalk8__default.default.dim("  3. Test fetching: fractary codex fetch codex://org/project/path"));
+          if (migrationResult.backupPath) {
+            console.log("");
+            console.log(chalk8__default.default.dim(`Backup saved: ${path3__namespace.basename(migrationResult.backupPath)}`));
+          }
         }
-        console.log(result.content.toString("utf-8"));
       }
     } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
-      if (error.message.includes("Failed to load configuration")) {
-        console.log(chalk6__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
-      } else if (error.message.includes("GITHUB_TOKEN")) {
-        console.log(chalk6__default.default.dim('\nSet your GitHub token: export GITHUB_TOKEN="your_token"'));
-      } else if (error.message.includes("not found") || error.message.includes("404")) {
-        console.log(chalk6__default.default.dim("\nThe document may not exist or you may not have access."));
-        console.log(chalk6__default.default.dim("Check the URI and ensure your storage providers are configured correctly."));
+      if (options.json) {
+        console.log(JSON.stringify({
+          status: "error",
+          message: error.message
+        }));
+      } else {
+        console.error(chalk8__default.default.red("Error:"), error.message);
       }
       process.exit(1);
     }
@@ -812,6 +970,15 @@ function fetchCommand() {
   return cmd;
 }
 
+// src/commands/config/index.ts
+function configCommand() {
+  const cmd = new commander.Command("config");
+  cmd.description("Manage configuration");
+  cmd.addCommand(initCommand());
+  cmd.addCommand(migrateCommand());
+  return cmd;
+}
+
 // src/commands/cache/index.ts
 init_cjs_shims();
 
@@ -832,8 +999,8 @@ function cacheListCommand() {
         if (options.json) {
           console.log(JSON.stringify({ entries: 0, message: "Cache is empty" }));
         } else {
-          console.log(chalk6__default.default.yellow("Cache is empty."));
-          console.log(chalk6__default.default.dim("Fetch some documents to populate the cache."));
+          console.log(chalk8__default.default.yellow("Cache is empty."));
+          console.log(chalk8__default.default.dim("Fetch some documents to populate the cache."));
         }
         return;
       }
@@ -847,25 +1014,25 @@ function cacheListCommand() {
         }, null, 2));
         return;
       }
-      console.log(chalk6__default.default.bold("Cache Overview\n"));
-      console.log(chalk6__default.default.bold("Entries:"));
-      console.log(`  Total:    ${chalk6__default.default.cyan(stats.entryCount.toString())} entries`);
-      console.log(`  Fresh:    ${chalk6__default.default.green(stats.freshCount.toString())} entries`);
-      console.log(`  Stale:    ${stats.staleCount > 0 ? chalk6__default.default.yellow(stats.staleCount.toString()) : chalk6__default.default.dim("0")} entries`);
-      console.log(`  Expired:  ${stats.expiredCount > 0 ? chalk6__default.default.red(stats.expiredCount.toString()) : chalk6__default.default.dim("0")} entries`);
+      console.log(chalk8__default.default.bold("Cache Overview\n"));
+      console.log(chalk8__default.default.bold("Entries:"));
+      console.log(`  Total:    ${chalk8__default.default.cyan(stats.entryCount.toString())} entries`);
+      console.log(`  Fresh:    ${chalk8__default.default.green(stats.freshCount.toString())} entries`);
+      console.log(`  Stale:    ${stats.staleCount > 0 ? chalk8__default.default.yellow(stats.staleCount.toString()) : chalk8__default.default.dim("0")} entries`);
+      console.log(`  Expired:  ${stats.expiredCount > 0 ? chalk8__default.default.red(stats.expiredCount.toString()) : chalk8__default.default.dim("0")} entries`);
       console.log("");
-      console.log(chalk6__default.default.bold("Storage:"));
-      console.log(`  Total size: ${chalk6__default.default.cyan(formatSize(stats.totalSize))}`);
+      console.log(chalk8__default.default.bold("Storage:"));
+      console.log(`  Total size: ${chalk8__default.default.cyan(formatSize(stats.totalSize))}`);
       console.log("");
       const healthPercent = stats.entryCount > 0 ? stats.freshCount / stats.entryCount * 100 : 100;
-      const healthColor = healthPercent > 80 ? chalk6__default.default.green : healthPercent > 50 ? chalk6__default.default.yellow : chalk6__default.default.red;
+      const healthColor = healthPercent > 80 ? chalk8__default.default.green : healthPercent > 50 ? chalk8__default.default.yellow : chalk8__default.default.red;
       console.log(`Cache health: ${healthColor(`${healthPercent.toFixed(0)}% fresh`)}`);
       console.log("");
-      console.log(chalk6__default.default.dim("Note: Individual cache entries are managed by the SDK."));
-      console.log(chalk6__default.default.dim('Use "fractary codex cache stats" for detailed statistics.'));
-      console.log(chalk6__default.default.dim('Use "fractary codex cache clear" to clear cache entries.'));
+      console.log(chalk8__default.default.dim("Note: Individual cache entries are managed by the SDK."));
+      console.log(chalk8__default.default.dim('Use "fractary codex cache stats" for detailed statistics.'));
+      console.log(chalk8__default.default.dim('Use "fractary codex cache clear" to clear cache entries.'));
     } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
+      console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
@@ -881,7 +1048,7 @@ function cacheClearCommand() {
       const client = await getClient();
       const statsBefore = await client.getCacheStats();
       if (statsBefore.entryCount === 0) {
-        console.log(chalk6__default.default.yellow("Cache is already empty. Nothing to clear."));
+        console.log(chalk8__default.default.yellow("Cache is already empty. Nothing to clear."));
         return;
       }
       let pattern;
@@ -890,45 +1057,45 @@ function cacheClearCommand() {
       } else if (options.pattern) {
         pattern = options.pattern;
       } else {
-        console.log(chalk6__default.default.yellow("Please specify what to clear:"));
-        console.log(chalk6__default.default.dim("  --all        Clear entire cache"));
-        console.log(chalk6__default.default.dim('  --pattern    Clear entries matching pattern (e.g., "codex://fractary/*")'));
+        console.log(chalk8__default.default.yellow("Please specify what to clear:"));
+        console.log(chalk8__default.default.dim("  --all        Clear entire cache"));
+        console.log(chalk8__default.default.dim('  --pattern    Clear entries matching pattern (e.g., "codex://fractary/*")'));
         console.log("");
-        console.log(chalk6__default.default.dim("Examples:"));
-        console.log(chalk6__default.default.dim("  fractary codex cache clear --all"));
-        console.log(chalk6__default.default.dim('  fractary codex cache clear --pattern "codex://fractary/cli/*"'));
+        console.log(chalk8__default.default.dim("Examples:"));
+        console.log(chalk8__default.default.dim("  fractary codex cache clear --all"));
+        console.log(chalk8__default.default.dim('  fractary codex cache clear --pattern "codex://fractary/cli/*"'));
         return;
       }
       if (options.dryRun) {
-        console.log(chalk6__default.default.blue("Dry run - would clear:\n"));
+        console.log(chalk8__default.default.blue("Dry run - would clear:\n"));
         if (pattern) {
-          console.log(chalk6__default.default.dim(`  Pattern: ${pattern}`));
-          console.log(chalk6__default.default.dim(`  This would invalidate matching cache entries`));
+          console.log(chalk8__default.default.dim(`  Pattern: ${pattern}`));
+          console.log(chalk8__default.default.dim(`  This would invalidate matching cache entries`));
         } else {
-          console.log(chalk6__default.default.dim(`  All cache entries (${statsBefore.entryCount} entries)`));
+          console.log(chalk8__default.default.dim(`  All cache entries (${statsBefore.entryCount} entries)`));
         }
-        console.log(chalk6__default.default.dim(`
+        console.log(chalk8__default.default.dim(`
 Total size: ${formatSize2(statsBefore.totalSize)}`));
         return;
       }
       if (pattern) {
-        console.log(chalk6__default.default.blue(`Clearing cache entries matching pattern: ${pattern}
+        console.log(chalk8__default.default.blue(`Clearing cache entries matching pattern: ${pattern}
 `));
         await client.invalidateCache(pattern);
       } else {
-        console.log(chalk6__default.default.blue(`Clearing entire cache (${statsBefore.entryCount} entries)...
+        console.log(chalk8__default.default.blue(`Clearing entire cache (${statsBefore.entryCount} entries)...
 `));
         await client.invalidateCache();
       }
       const statsAfter = await client.getCacheStats();
       const entriesCleared = statsBefore.entryCount - statsAfter.entryCount;
       const sizeFreed = statsBefore.totalSize - statsAfter.totalSize;
-      console.log(chalk6__default.default.green(`\u2713 Cleared ${entriesCleared} entries (${formatSize2(sizeFreed)} freed)`));
+      console.log(chalk8__default.default.green(`\u2713 Cleared ${entriesCleared} entries (${formatSize2(sizeFreed)} freed)`));
       if (statsAfter.entryCount > 0) {
-        console.log(chalk6__default.default.dim(`  Remaining: ${statsAfter.entryCount} entries (${formatSize2(statsAfter.totalSize)})`));
+        console.log(chalk8__default.default.dim(`  Remaining: ${statsAfter.entryCount} entries (${formatSize2(statsAfter.totalSize)})`));
       }
     } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
+      console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
@@ -957,557 +1124,560 @@ function cacheStatsCommand() {
         console.log(JSON.stringify(stats, null, 2));
         return;
       }
-      console.log(chalk6__default.default.bold("Cache Statistics\n"));
-      console.log(chalk6__default.default.bold("Overview"));
-      console.log(`  Total entries:     ${chalk6__default.default.cyan(stats.entryCount.toString())}`);
-      console.log(`  Total size:        ${chalk6__default.default.cyan(formatSize3(stats.totalSize))}`);
-      console.log(`  Fresh entries:     ${chalk6__default.default.green(stats.freshCount.toString())}`);
-      console.log(`  Stale entries:     ${stats.staleCount > 0 ? chalk6__default.default.yellow(stats.staleCount.toString()) : chalk6__default.default.dim("0")}`);
-      console.log(`  Expired entries:   ${stats.expiredCount > 0 ? chalk6__default.default.red(stats.expiredCount.toString()) : chalk6__default.default.dim("0")}`);
+      console.log(chalk8__default.default.bold("Cache Statistics\n"));
+      console.log(chalk8__default.default.bold("Overview"));
+      console.log(`  Total entries:     ${chalk8__default.default.cyan(stats.entryCount.toString())}`);
+      console.log(`  Total size:        ${chalk8__default.default.cyan(formatSize3(stats.totalSize))}`);
+      console.log(`  Fresh entries:     ${chalk8__default.default.green(stats.freshCount.toString())}`);
+      console.log(`  Stale entries:     ${stats.staleCount > 0 ? chalk8__default.default.yellow(stats.staleCount.toString()) : chalk8__default.default.dim("0")}`);
+      console.log(`  Expired entries:   ${stats.expiredCount > 0 ? chalk8__default.default.red(stats.expiredCount.toString()) : chalk8__default.default.dim("0")}`);
       console.log("");
       const healthPercent = stats.entryCount > 0 ? stats.freshCount / stats.entryCount * 100 : 100;
-      const healthColor = healthPercent > 80 ? chalk6__default.default.green : healthPercent > 50 ? chalk6__default.default.yellow : chalk6__default.default.red;
+      const healthColor = healthPercent > 80 ? chalk8__default.default.green : healthPercent > 50 ? chalk8__default.default.yellow : chalk8__default.default.red;
       console.log(`Cache health: ${healthColor(`${healthPercent.toFixed(0)}% fresh`)}`);
       if (stats.expiredCount > 0) {
-        console.log(chalk6__default.default.dim('\nRun "fractary codex cache clear --pattern <pattern>" to clean up entries.'));
+        console.log(chalk8__default.default.dim('\nRun "fractary codex cache clear --pattern <pattern>" to clean up entries.'));
       }
       if (stats.entryCount === 0) {
-        console.log(chalk6__default.default.dim("\nNo cached entries. Fetch some documents to populate the cache."));
+        console.log(chalk8__default.default.dim("\nNo cached entries. Fetch some documents to populate the cache."));
       }
     } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
+      console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
   return cmd;
 }
 
-// src/commands/cache/index.ts
-function cacheCommand() {
-  const cmd = new commander.Command("cache");
-  cmd.description("Manage the codex document cache");
-  cmd.addCommand(cacheListCommand());
-  cmd.addCommand(cacheClearCommand());
-  cmd.addCommand(cacheStatsCommand());
-  return cmd;
-}
-
-// src/commands/sync/index.ts
-init_cjs_shims();
-
-// src/commands/sync/project.ts
+// src/commands/cache/health.ts
 init_cjs_shims();
 init_migrate_config();
-function getEnvironmentBranch(config, env) {
-  const envMap = config.sync?.environments || {
-    dev: "develop",
-    test: "test",
-    staging: "staging",
-    prod: "main"
-  };
-  return envMap[env] || env;
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-function formatDuration(ms) {
-  if (ms < 1e3) return `${ms}ms`;
-  return `${(ms / 1e3).toFixed(1)}s`;
+async function fileExists3(filePath) {
+  try {
+    await fs__namespace.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function syncProjectCommand() {
-  const cmd = new commander.Command("project");
-  cmd.description("Sync single project with codex repository").argument("[name]", "Project name (auto-detected if not provided)").option("--env <env>", "Target environment (dev/test/staging/prod)", "prod").option("--dry-run", "Show what would sync without executing").option("--direction <dir>", "Sync direction (to-codex/from-codex/bidirectional)", "bidirectional").option("--include <pattern>", "Include files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--exclude <pattern>", "Exclude files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--force", "Force sync without checking timestamps").option("--json", "Output as JSON").action(async (name, options) => {
-    try {
-      const configPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
-      let config;
-      try {
-        config = await readYamlConfig(configPath);
-      } catch (error) {
-        console.error(chalk6__default.default.red("Error:"), "Codex not initialized.");
-        console.log(chalk6__default.default.dim('Run "fractary codex init" first.'));
-        process.exit(1);
-      }
-      const { createSyncManager, createLocalStorage, detectCurrentProject } = await import('@fractary/codex');
-      let projectName = name;
-      if (!projectName) {
-        const detected = detectCurrentProject();
-        projectName = detected.project || null;
-      }
-      if (!projectName) {
-        console.error(chalk6__default.default.red("Error:"), "Could not determine project name.");
-        console.log(chalk6__default.default.dim("Provide project name as argument or run from a git repository."));
-        process.exit(1);
-      }
-      const validDirections = ["to-codex", "from-codex", "bidirectional"];
-      if (!validDirections.includes(options.direction)) {
-        console.error(chalk6__default.default.red("Error:"), `Invalid direction: ${options.direction}`);
-        console.log(chalk6__default.default.dim("Valid options: to-codex, from-codex, bidirectional"));
-        process.exit(1);
-      }
-      const direction = options.direction;
-      const targetBranch = getEnvironmentBranch(config, options.env);
-      const localStorage = createLocalStorage({
-        baseDir: process.cwd()
-      });
-      const syncManager = createSyncManager({
-        localStorage,
-        config: config.sync,
-        manifestPath: path2__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
-      });
-      const defaultPatterns = config.sync?.include || [
-        "docs/**/*.md",
-        "specs/**/*.md",
-        ".fractary/standards/**",
-        ".fractary/templates/**"
-      ];
-      const includePatterns = options.include.length > 0 ? options.include : defaultPatterns;
-      const excludePatterns = [
-        ...config.sync?.exclude || [],
-        ...options.exclude
-      ];
-      const sourceDir = process.cwd();
-      const allFiles = await syncManager.listLocalFiles(sourceDir);
-      const targetFiles = allFiles.filter((file) => {
-        for (const pattern of excludePatterns) {
-          const regex = new RegExp("^" + pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*") + "$");
-          if (regex.test(file.path)) {
-            return false;
-          }
-        }
-        for (const pattern of includePatterns) {
-          const regex = new RegExp("^" + pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*") + "$");
-          if (regex.test(file.path)) {
-            return true;
-          }
-        }
-        return false;
-      });
-      const syncOptions = {
-        direction,
-        dryRun: options.dryRun,
-        force: options.force,
-        include: includePatterns,
-        exclude: excludePatterns
-      };
-      const plan = await syncManager.createPlan(
-        config.organization,
-        projectName,
-        sourceDir,
-        targetFiles,
-        syncOptions
-      );
-      if (plan.totalFiles === 0) {
-        if (options.json) {
-          console.log(JSON.stringify({
-            project: projectName,
-            organization: config.organization,
-            files: [],
-            synced: 0
-          }, null, 2));
-        } else {
-          console.log(chalk6__default.default.yellow("No files to sync."));
-        }
-        return;
-      }
-      if (options.json) {
-        const output = {
-          project: projectName,
-          organization: config.organization,
-          environment: options.env,
-          branch: targetBranch,
-          direction,
-          dryRun: options.dryRun || false,
-          plan: {
-            totalFiles: plan.totalFiles,
-            totalBytes: plan.totalBytes,
-            estimatedTime: plan.estimatedTime,
-            conflicts: plan.conflicts.length,
-            skipped: plan.skipped.length
-          },
-          files: plan.files.map((f) => ({
-            path: f.path,
-            operation: f.operation,
-            size: f.size
-          }))
+async function checkConfiguration() {
+  const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex.yaml");
+  const legacyConfigPath = path3__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
+  try {
+    if (!await fileExists3(configPath)) {
+      if (await fileExists3(legacyConfigPath)) {
+        return {
+          name: "Configuration",
+          status: "warn",
+          message: "Legacy JSON configuration detected",
+          details: 'Run "fractary codex migrate" to upgrade to YAML format'
         };
-        if (options.dryRun) {
-          console.log(JSON.stringify(output, null, 2));
-          return;
-        }
-        const result2 = await syncManager.executePlan(plan, syncOptions);
-        console.log(JSON.stringify({
-          ...output,
-          result: {
-            success: result2.success,
-            synced: result2.synced,
-            failed: result2.failed,
-            skipped: result2.skipped,
-            duration: result2.duration,
-            errors: result2.errors
-          }
-        }, null, 2));
-        return;
-      }
-      console.log(chalk6__default.default.bold("Sync Plan\n"));
-      console.log(`  Project:      ${chalk6__default.default.cyan(projectName)}`);
-      console.log(`  Organization: ${chalk6__default.default.cyan(config.organization)}`);
-      console.log(`  Environment:  ${chalk6__default.default.cyan(options.env)} (${targetBranch})`);
-      console.log(`  Direction:    ${chalk6__default.default.cyan(direction)}`);
-      console.log(`  Files:        ${chalk6__default.default.cyan(plan.totalFiles.toString())}`);
-      console.log(`  Total size:   ${chalk6__default.default.cyan(formatBytes(plan.totalBytes))}`);
-      if (plan.estimatedTime) {
-        console.log(`  Est. time:    ${chalk6__default.default.dim(formatDuration(plan.estimatedTime))}`);
-      }
-      console.log("");
-      if (plan.conflicts.length > 0) {
-        console.log(chalk6__default.default.yellow(`\u26A0 ${plan.conflicts.length} conflicts detected:`));
-        for (const conflict of plan.conflicts.slice(0, 5)) {
-          console.log(chalk6__default.default.yellow(`  \u2022 ${conflict.path}`));
-        }
-        if (plan.conflicts.length > 5) {
-          console.log(chalk6__default.default.dim(`  ... and ${plan.conflicts.length - 5} more`));
-        }
-        console.log("");
-      }
-      if (plan.skipped.length > 0) {
-        console.log(chalk6__default.default.dim(`${plan.skipped.length} files skipped (no changes)`));
-        console.log("");
-      }
-      if (options.dryRun) {
-        console.log(chalk6__default.default.blue("Dry run - would sync:\n"));
-        const filesToShow = plan.files.slice(0, 10);
-        for (const file of filesToShow) {
-          const arrow = direction === "to-codex" ? "\u2192" : direction === "from-codex" ? "\u2190" : "\u2194";
-          const opColor = file.operation === "create" ? chalk6__default.default.green : file.operation === "update" ? chalk6__default.default.yellow : chalk6__default.default.dim;
-          console.log(
-            chalk6__default.default.dim(`  ${arrow}`),
-            opColor(file.operation.padEnd(7)),
-            file.path,
-            chalk6__default.default.dim(`(${formatBytes(file.size || 0)})`)
-          );
-        }
-        if (plan.files.length > 10) {
-          console.log(chalk6__default.default.dim(`  ... and ${plan.files.length - 10} more files`));
-        }
-        console.log(chalk6__default.default.dim(`
-Total: ${plan.totalFiles} files (${formatBytes(plan.totalBytes)})`));
-        console.log(chalk6__default.default.dim("Run without --dry-run to execute sync."));
-        return;
-      }
-      console.log(chalk6__default.default.blue("Syncing...\n"));
-      const startTime = Date.now();
-      const result = await syncManager.executePlan(plan, syncOptions);
-      const duration = Date.now() - startTime;
-      console.log("");
-      if (result.success) {
-        console.log(chalk6__default.default.green(`\u2713 Sync completed successfully`));
-        console.log(chalk6__default.default.dim(`  Synced: ${result.synced} files`));
-        if (result.skipped > 0) {
-          console.log(chalk6__default.default.dim(`  Skipped: ${result.skipped} files`));
-        }
-        console.log(chalk6__default.default.dim(`  Duration: ${formatDuration(duration)}`));
-      } else {
-        console.log(chalk6__default.default.yellow(`\u26A0 Sync completed with errors`));
-        console.log(chalk6__default.default.green(`  Synced: ${result.synced} files`));
-        console.log(chalk6__default.default.red(`  Failed: ${result.failed} files`));
-        if (result.skipped > 0) {
-          console.log(chalk6__default.default.dim(`  Skipped: ${result.skipped} files`));
-        }
-        if (result.errors.length > 0) {
-          console.log("");
-          console.log(chalk6__default.default.red("Errors:"));
-          for (const error of result.errors.slice(0, 5)) {
-            console.log(chalk6__default.default.red(`  \u2022 ${error.path}: ${error.error}`));
-          }
-          if (result.errors.length > 5) {
-            console.log(chalk6__default.default.dim(`  ... and ${result.errors.length - 5} more errors`));
-          }
-        }
       }
-    } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
-      process.exit(1);
+      return {
+        name: "Configuration",
+        status: "fail",
+        message: "No configuration found",
+        details: 'Run "fractary codex init" to create configuration'
+      };
     }
-  });
-  return cmd;
-}
-
-// src/commands/sync/org.ts
-init_cjs_shims();
-init_migrate_config();
-function getEnvironmentBranch2(config, env) {
-  const envMap = config.sync?.environments || {
-    dev: "develop",
-    test: "test",
-    staging: "staging",
-    prod: "main"
-  };
-  return envMap[env] || env;
-}
-async function discoverRepos(org) {
-  try {
-    const output = child_process.execSync(
-      `gh repo list ${org} --json name,url,defaultBranchRef --limit 100`,
-      { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
-    );
-    const repos = JSON.parse(output);
-    return repos.map((repo) => ({
-      name: repo.name,
-      url: repo.url,
-      defaultBranch: repo.defaultBranchRef?.name || "main"
-    }));
+    const config = await readYamlConfig(configPath);
+    if (!config.organization) {
+      return {
+        name: "Configuration",
+        status: "warn",
+        message: "No organization configured",
+        details: "Organization slug is required"
+      };
+    }
+    const providerCount = config.storage?.length || 0;
+    if (providerCount === 0) {
+      return {
+        name: "Configuration",
+        status: "warn",
+        message: "No storage providers configured",
+        details: "At least one storage provider is recommended"
+      };
+    }
+    return {
+      name: "Configuration",
+      status: "pass",
+      message: "Valid YAML configuration",
+      details: `Organization: ${config.organization}, ${providerCount} storage provider(s)`
+    };
   } catch (error) {
-    throw new Error(`Failed to discover repos: ${error.message}. Ensure GitHub CLI is installed and authenticated.`);
+    return {
+      name: "Configuration",
+      status: "fail",
+      message: "Invalid configuration",
+      details: error.message
+    };
   }
 }
-function shouldExclude(repoName, excludePatterns) {
-  for (const pattern of excludePatterns) {
-    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
-    if (regex.test(repoName)) {
-      return true;
-    }
+async function checkSDKClient() {
+  try {
+    const client = await getClient();
+    const organization = client.getOrganization();
+    return {
+      name: "SDK Client",
+      status: "pass",
+      message: "CodexClient initialized successfully",
+      details: `Organization: ${organization}`
+    };
+  } catch (error) {
+    return {
+      name: "SDK Client",
+      status: "fail",
+      message: "Failed to initialize CodexClient",
+      details: error.message
+    };
   }
-  return false;
 }
-async function syncRepository(repo, config, direction, syncOptions) {
-  const startTime = Date.now();
+async function checkCache() {
   try {
-    const { createSyncManager, createLocalStorage } = await import('@fractary/codex');
-    const repoDir = path2__namespace.join(process.cwd(), "..", repo.name);
-    const localStorage = createLocalStorage({
-      baseDir: repoDir
-    });
-    const syncManager = createSyncManager({
-      localStorage,
-      config: config.sync,
-      manifestPath: path2__namespace.join(repoDir, ".fractary", ".codex-sync-manifest.json")
-    });
-    const includePatterns = config.sync?.include || [
-      "docs/**/*.md",
-      "specs/**/*.md",
-      ".fractary/standards/**",
-      ".fractary/templates/**"
-    ];
-    const allFiles = await syncManager.listLocalFiles(repoDir);
-    const targetFiles = allFiles.filter((file) => {
-      for (const pattern of includePatterns) {
-        const regex = new RegExp("^" + pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*") + "$");
-        if (regex.test(file.path)) {
-          return true;
-        }
-      }
-      return false;
-    });
-    const plan = await syncManager.createPlan(
-      config.organization,
-      repo.name,
-      repoDir,
-      targetFiles,
-      syncOptions
-    );
-    if (plan.totalFiles === 0) {
+    const client = await getClient();
+    const stats = await client.getCacheStats();
+    if (stats.entryCount === 0) {
+      return {
+        name: "Cache",
+        status: "warn",
+        message: "Cache is empty",
+        details: "Fetch some documents to populate cache"
+      };
+    }
+    const healthPercent = stats.entryCount > 0 ? stats.freshCount / stats.entryCount * 100 : 100;
+    if (healthPercent < 50) {
       return {
-        repo: repo.name,
-        status: "skipped",
-        filesSynced: 0,
-        duration: Date.now() - startTime
+        name: "Cache",
+        status: "warn",
+        message: `${stats.entryCount} entries (${healthPercent.toFixed(0)}% fresh)`,
+        details: `${stats.expiredCount} expired, ${stats.staleCount} stale`
       };
     }
-    const result = await syncManager.executePlan(plan, syncOptions);
     return {
-      repo: repo.name,
-      status: result.success ? "success" : "error",
-      filesSynced: result.synced,
-      duration: Date.now() - startTime,
-      error: result.success ? void 0 : `${result.failed} files failed`
+      name: "Cache",
+      status: "pass",
+      message: `${stats.entryCount} entries (${healthPercent.toFixed(0)}% fresh)`,
+      details: `${formatSize4(stats.totalSize)} total`
     };
   } catch (error) {
     return {
-      repo: repo.name,
-      status: "error",
-      duration: Date.now() - startTime,
-      error: error.message
+      name: "Cache",
+      status: "fail",
+      message: "Cache check failed",
+      details: error.message
     };
   }
 }
-function syncOrgCommand() {
-  const cmd = new commander.Command("org");
-  cmd.description("Sync all projects in organization with codex repository").option("--env <env>", "Target environment (dev/test/staging/prod)", "prod").option("--dry-run", "Show what would sync without executing").option("--exclude <pattern>", "Exclude repos matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--parallel <n>", "Number of parallel syncs", parseInt, 3).option("--direction <dir>", "Sync direction (to-codex/from-codex/bidirectional)", "bidirectional").option("--json", "Output as JSON").action(async (options) => {
+async function checkStorage() {
+  const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex.yaml");
+  try {
+    const config = await readYamlConfig(configPath);
+    const providers = config.storage || [];
+    if (providers.length === 0) {
+      return {
+        name: "Storage",
+        status: "warn",
+        message: "No storage providers configured",
+        details: "Configure at least one provider in .fractary/codex.yaml"
+      };
+    }
+    const providerTypes = providers.map((p) => p.type).join(", ");
+    const hasGitHub = providers.some((p) => p.type === "github");
+    if (hasGitHub && !process.env.GITHUB_TOKEN) {
+      return {
+        name: "Storage",
+        status: "warn",
+        message: `${providers.length} provider(s): ${providerTypes}`,
+        details: "GITHUB_TOKEN not set (required for GitHub provider)"
+      };
+    }
+    return {
+      name: "Storage",
+      status: "pass",
+      message: `${providers.length} provider(s): ${providerTypes}`,
+      details: "All configured providers available"
+    };
+  } catch (error) {
+    return {
+      name: "Storage",
+      status: "fail",
+      message: "Storage check failed",
+      details: error.message
+    };
+  }
+}
+async function checkTypes() {
+  try {
+    const client = await getClient();
+    const registry = client.getTypeRegistry();
+    const allTypes = registry.list();
+    const builtinCount = allTypes.filter((t) => registry.isBuiltIn(t.name)).length;
+    const customCount = allTypes.length - builtinCount;
+    return {
+      name: "Type Registry",
+      status: "pass",
+      message: `${allTypes.length} types registered`,
+      details: `${builtinCount} built-in, ${customCount} custom`
+    };
+  } catch (error) {
+    return {
+      name: "Type Registry",
+      status: "fail",
+      message: "Type registry check failed",
+      details: error.message
+    };
+  }
+}
+function formatSize4(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function healthCommand() {
+  const cmd = new commander.Command("health");
+  cmd.description("Run diagnostics on codex setup").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const checks = [];
+      checks.push(await checkConfiguration());
+      checks.push(await checkSDKClient());
+      checks.push(await checkCache());
+      checks.push(await checkStorage());
+      checks.push(await checkTypes());
+      const passed = checks.filter((c) => c.status === "pass").length;
+      const warned = checks.filter((c) => c.status === "warn").length;
+      const failed = checks.filter((c) => c.status === "fail").length;
+      if (options.json) {
+        console.log(JSON.stringify({
+          summary: {
+            total: checks.length,
+            passed,
+            warned,
+            failed,
+            healthy: failed === 0
+          },
+          checks
+        }, null, 2));
+        return;
+      }
+      console.log(chalk8__default.default.bold("Codex Health Check\n"));
+      for (const check of checks) {
+        const icon = check.status === "pass" ? chalk8__default.default.green("\u2713") : check.status === "warn" ? chalk8__default.default.yellow("\u26A0") : chalk8__default.default.red("\u2717");
+        const statusColor = check.status === "pass" ? chalk8__default.default.green : check.status === "warn" ? chalk8__default.default.yellow : chalk8__default.default.red;
+        console.log(`${icon} ${chalk8__default.default.bold(check.name)}`);
+        console.log(`  ${statusColor(check.message)}`);
+        if (check.details) {
+          console.log(`  ${chalk8__default.default.dim(check.details)}`);
+        }
+        console.log("");
+      }
+      console.log(chalk8__default.default.dim("\u2500".repeat(60)));
+      const overallStatus = failed > 0 ? chalk8__default.default.red("UNHEALTHY") : warned > 0 ? chalk8__default.default.yellow("DEGRADED") : chalk8__default.default.green("HEALTHY");
+      console.log(`Status: ${overallStatus}`);
+      console.log(chalk8__default.default.dim(`${passed} passed, ${warned} warnings, ${failed} failed`));
+      if (failed > 0 || warned > 0) {
+        console.log("");
+        console.log(chalk8__default.default.dim("Run checks individually for more details:"));
+        console.log(chalk8__default.default.dim("  fractary codex cache stats"));
+        console.log(chalk8__default.default.dim("  fractary codex types list"));
+      }
+      if (failed > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk8__default.default.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/cache/index.ts
+function cacheCommand() {
+  const cmd = new commander.Command("cache");
+  cmd.description("Manage the codex document cache");
+  cmd.addCommand(cacheListCommand());
+  cmd.addCommand(cacheClearCommand());
+  cmd.addCommand(cacheStatsCommand());
+  cmd.addCommand(healthCommand());
+  return cmd;
+}
+
+// src/commands/sync.ts
+init_cjs_shims();
+init_migrate_config();
+function getEnvironmentBranch(config, env) {
+  const envMap = config.sync?.environments || {
+    dev: "develop",
+    test: "test",
+    staging: "staging",
+    prod: "main"
+  };
+  return envMap[env] || env;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function syncCommand() {
+  const cmd = new commander.Command("sync");
+  cmd.description("Sync single project with codex repository").argument("[name]", "Project name (auto-detected if not provided)").option("--env <env>", "Target environment (dev/test/staging/prod)", "prod").option("--dry-run", "Show what would sync without executing").option("--direction <dir>", "Sync direction (to-codex/from-codex/bidirectional)", "bidirectional").option("--include <pattern>", "Include files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--exclude <pattern>", "Exclude files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--force", "Force sync without checking timestamps").option("--json", "Output as JSON").action(async (name, options) => {
     try {
-      const configPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
+      const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex.yaml");
       let config;
       try {
         config = await readYamlConfig(configPath);
       } catch (error) {
-        console.error(chalk6__default.default.red("Error:"), "Codex not initialized.");
-        console.log(chalk6__default.default.dim('Run "fractary codex init" first.'));
+        console.error(chalk8__default.default.red("Error:"), "Codex not initialized.");
+        console.log(chalk8__default.default.dim('Run "fractary codex init" first.'));
+        process.exit(1);
+      }
+      const { createSyncManager, createLocalStorage, detectCurrentProject } = await import('@fractary/codex');
+      let projectName = name;
+      if (!projectName) {
+        const detected = detectCurrentProject();
+        projectName = detected.project || void 0;
+      }
+      if (!projectName) {
+        console.error(chalk8__default.default.red("Error:"), "Could not determine project name.");
+        console.log(chalk8__default.default.dim("Provide project name as argument or run from a git repository."));
         process.exit(1);
       }
       const validDirections = ["to-codex", "from-codex", "bidirectional"];
       if (!validDirections.includes(options.direction)) {
-        console.error(chalk6__default.default.red("Error:"), `Invalid direction: ${options.direction}`);
-        console.log(chalk6__default.default.dim("Valid options: to-codex, from-codex, bidirectional"));
+        console.error(chalk8__default.default.red("Error:"), `Invalid direction: ${options.direction}`);
+        console.log(chalk8__default.default.dim("Valid options: to-codex, from-codex, bidirectional"));
         process.exit(1);
       }
       const direction = options.direction;
-      const org = config.organization;
-      const targetBranch = getEnvironmentBranch2(config, options.env);
+      const targetBranch = getEnvironmentBranch(config, options.env);
+      const localStorage = createLocalStorage({
+        baseDir: process.cwd()
+      });
+      const syncManager = createSyncManager({
+        localStorage,
+        config: config.sync,
+        manifestPath: path3__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
+      });
+      const defaultPatterns = [
+        "docs/**/*.md",
+        "specs/**/*.md",
+        ".fractary/standards/**",
+        ".fractary/templates/**"
+      ];
+      const includePatterns = options.include.length > 0 ? options.include : defaultPatterns;
       const excludePatterns = [
         ...config.sync?.exclude || [],
         ...options.exclude
       ];
-      if (!options.json) {
-        console.log(chalk6__default.default.bold("Organization Sync\n"));
-        console.log(`  Organization: ${chalk6__default.default.cyan(org)}`);
-        console.log(`  Environment:  ${chalk6__default.default.cyan(options.env)} (${targetBranch})`);
-        console.log(`  Direction:    ${chalk6__default.default.cyan(direction)}`);
-        console.log(`  Parallelism:  ${chalk6__default.default.cyan(options.parallel.toString())}`);
-        if (excludePatterns.length > 0) {
-          console.log(`  Excluding:    ${chalk6__default.default.dim(excludePatterns.join(", "))}`);
+      const sourceDir = process.cwd();
+      const allFiles = await syncManager.listLocalFiles(sourceDir);
+      const targetFiles = allFiles.filter((file) => {
+        for (const pattern of excludePatterns) {
+          const regex = new RegExp("^" + pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*") + "$");
+          if (regex.test(file.path)) {
+            return false;
+          }
         }
-        console.log("");
-        console.log(chalk6__default.default.dim("Discovering repositories..."));
-      }
-      let repos;
-      try {
-        repos = await discoverRepos(org);
-      } catch (error) {
+        for (const pattern of includePatterns) {
+          const regex = new RegExp("^" + pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*") + "$");
+          if (regex.test(file.path)) {
+            return true;
+          }
+        }
+        return false;
+      });
+      const syncOptions = {
+        direction,
+        dryRun: options.dryRun,
+        force: options.force,
+        include: includePatterns,
+        exclude: excludePatterns
+      };
+      let plan;
+      let routingScan;
+      if (direction === "from-codex") {
+        const codexRepoPath = config.cacheDir || path3__namespace.join(process.cwd(), ".fractary", "codex-cache");
         if (options.json) {
-          console.log(JSON.stringify({ error: error.message }));
+          console.log(JSON.stringify({
+            info: "Routing-aware sync: scanning entire codex repository for files targeting this project",
+            codexPath: codexRepoPath
+          }, null, 2));
         } else {
-          console.error(chalk6__default.default.red("Error:"), error.message);
+          console.log(chalk8__default.default.blue("\u2139 Using routing-aware sync"));
+          console.log(chalk8__default.default.dim("  Scanning entire codex for files routing to this project...\n"));
         }
-        process.exit(1);
-      }
-      const eligibleRepos = repos.filter((repo) => !shouldExclude(repo.name, excludePatterns));
-      const excludedRepos = repos.filter((repo) => shouldExclude(repo.name, excludePatterns));
-      if (!options.json) {
-        console.log(chalk6__default.default.dim(`Found ${repos.length} repositories (${excludedRepos.length} excluded)
-`));
+        const planWithRouting = await syncManager.createRoutingAwarePlan(
+          config.organization,
+          projectName,
+          codexRepoPath,
+          syncOptions
+        );
+        plan = planWithRouting;
+        routingScan = planWithRouting.routingScan;
+      } else {
+        plan = await syncManager.createPlan(
+          config.organization,
+          projectName,
+          sourceDir,
+          targetFiles,
+          syncOptions
+        );
       }
-      if (options.dryRun) {
+      if (plan.totalFiles === 0) {
         if (options.json) {
           console.log(JSON.stringify({
-            organization: org,
-            environment: options.env,
-            branch: targetBranch,
-            direction,
-            dryRun: true,
-            repos: {
-              total: repos.length,
-              eligible: eligibleRepos.map((r) => r.name),
-              excluded: excludedRepos.map((r) => r.name)
-            }
+            project: projectName,
+            organization: config.organization,
+            files: [],
+            synced: 0
           }, null, 2));
         } else {
-          console.log(chalk6__default.default.blue("Dry run - would sync:\n"));
-          for (const repo of eligibleRepos) {
-            console.log(chalk6__default.default.green("  \u2713"), repo.name);
-          }
-          if (excludedRepos.length > 0) {
-            console.log("");
-            console.log(chalk6__default.default.dim("Excluded:"));
-            for (const repo of excludedRepos) {
-              console.log(chalk6__default.default.dim(`  - ${repo.name}`));
-            }
-          }
-          console.log(chalk6__default.default.dim(`
-Total: ${eligibleRepos.length} repos would be synced`));
-          console.log(chalk6__default.default.dim("Run without --dry-run to execute sync."));
+          console.log(chalk8__default.default.yellow("No files to sync."));
         }
         return;
       }
-      if (!options.json) {
-        console.log(chalk6__default.default.blue("Syncing repositories...\n"));
-      }
-      const results = [];
-      const syncOptions = {
-        direction,
-        dryRun: false,
-        force: false
-      };
-      for (let i = 0; i < eligibleRepos.length; i += options.parallel) {
-        const batch = eligibleRepos.slice(i, i + options.parallel);
-        const batchResults = await Promise.all(
-          batch.map((repo) => syncRepository(repo, config, direction, syncOptions))
-        );
-        for (const result of batchResults) {
-          results.push(result);
-          if (!options.json) {
-            if (result.status === "success") {
-              console.log(
-                chalk6__default.default.green("  \u2713"),
-                result.repo,
-                chalk6__default.default.dim(`(${result.filesSynced} files in ${result.duration}ms)`)
-              );
-            } else if (result.status === "skipped") {
-              console.log(
-                chalk6__default.default.dim("  -"),
-                result.repo,
-                chalk6__default.default.dim("(no files to sync)")
-              );
-            } else if (result.status === "error") {
-              console.log(
-                chalk6__default.default.red("  \u2717"),
-                result.repo,
-                chalk6__default.default.red(`(${result.error})`)
-              );
-            }
-          }
-        }
-      }
-      const successful = results.filter((r) => r.status === "success");
-      const skipped = results.filter((r) => r.status === "skipped");
-      const failed = results.filter((r) => r.status === "error");
-      const totalFiles = successful.reduce((sum, r) => sum + (r.filesSynced || 0), 0);
       if (options.json) {
-        console.log(JSON.stringify({
-          organization: org,
+        const output = {
+          project: projectName,
+          organization: config.organization,
           environment: options.env,
           branch: targetBranch,
           direction,
-          results: {
-            total: results.length,
-            successful: successful.length,
-            skipped: skipped.length,
-            failed: failed.length,
-            filesSynced: totalFiles,
-            details: results
+          dryRun: options.dryRun || false,
+          plan: {
+            totalFiles: plan.totalFiles,
+            totalBytes: plan.totalBytes,
+            estimatedTime: plan.estimatedTime,
+            conflicts: plan.conflicts.length,
+            skipped: plan.skipped.length
+          },
+          files: plan.files.map((f) => ({
+            path: f.path,
+            operation: f.operation,
+            size: f.size
+          }))
+        };
+        if (options.dryRun) {
+          console.log(JSON.stringify(output, null, 2));
+          return;
+        }
+        const result2 = await syncManager.executePlan(plan, syncOptions);
+        console.log(JSON.stringify({
+          ...output,
+          result: {
+            success: result2.success,
+            synced: result2.synced,
+            failed: result2.failed,
+            skipped: result2.skipped,
+            duration: result2.duration,
+            errors: result2.errors
           }
         }, null, 2));
-      } else {
+        return;
+      }
+      console.log(chalk8__default.default.bold("Sync Plan\n"));
+      console.log(`  Project:      ${chalk8__default.default.cyan(projectName)}`);
+      console.log(`  Organization: ${chalk8__default.default.cyan(config.organization)}`);
+      console.log(`  Environment:  ${chalk8__default.default.cyan(options.env)} (${targetBranch})`);
+      console.log(`  Direction:    ${chalk8__default.default.cyan(direction)}`);
+      console.log(`  Files:        ${chalk8__default.default.cyan(plan.totalFiles.toString())}`);
+      console.log(`  Total size:   ${chalk8__default.default.cyan(formatBytes(plan.totalBytes))}`);
+      if (plan.estimatedTime) {
+        console.log(`  Est. time:    ${chalk8__default.default.dim(formatDuration(plan.estimatedTime))}`);
+      }
+      if (routingScan) {
         console.log("");
-        console.log(chalk6__default.default.green(`\u2713 Synced ${successful.length}/${results.length} repos (${totalFiles} files)`));
-        if (skipped.length > 0) {
-          console.log(chalk6__default.default.dim(`  Skipped ${skipped.length} repos (no changes)`));
+        console.log(chalk8__default.default.bold("Routing Statistics\n"));
+        console.log(`  Scanned:      ${chalk8__default.default.cyan(routingScan.stats.totalScanned.toString())} files`);
+        console.log(`  Matched:      ${chalk8__default.default.cyan(routingScan.stats.totalMatched.toString())} files`);
+        console.log(`  Source projects: ${chalk8__default.default.cyan(routingScan.stats.sourceProjects.length.toString())}`);
+        if (routingScan.stats.sourceProjects.length > 0) {
+          console.log(chalk8__default.default.dim(`    ${routingScan.stats.sourceProjects.slice(0, 5).join(", ")}`));
+          if (routingScan.stats.sourceProjects.length > 5) {
+            console.log(chalk8__default.default.dim(`    ... and ${routingScan.stats.sourceProjects.length - 5} more`));
+          }
+        }
+        console.log(`  Scan time:    ${chalk8__default.default.dim(formatDuration(routingScan.stats.durationMs))}`);
+      }
+      console.log("");
+      if (plan.conflicts.length > 0) {
+        console.log(chalk8__default.default.yellow(`\u26A0 ${plan.conflicts.length} conflicts detected:`));
+        for (const conflict of plan.conflicts.slice(0, 5)) {
+          console.log(chalk8__default.default.yellow(`  \u2022 ${conflict.path}`));
         }
-        if (failed.length > 0) {
-          console.log(chalk6__default.default.red(`\u2717 ${failed.length} repos failed`));
+        if (plan.conflicts.length > 5) {
+          console.log(chalk8__default.default.dim(`  ... and ${plan.conflicts.length - 5} more`));
         }
+        console.log("");
       }
-    } catch (error) {
-      if (options.json) {
-        console.log(JSON.stringify({ error: error.message }));
+      if (plan.skipped.length > 0) {
+        console.log(chalk8__default.default.dim(`${plan.skipped.length} files skipped (no changes)`));
+        console.log("");
+      }
+      if (options.dryRun) {
+        console.log(chalk8__default.default.blue("Dry run - would sync:\n"));
+        const filesToShow = plan.files.slice(0, 10);
+        for (const file of filesToShow) {
+          const arrow = direction === "to-codex" ? "\u2192" : direction === "from-codex" ? "\u2190" : "\u2194";
+          const opColor = file.operation === "create" ? chalk8__default.default.green : file.operation === "update" ? chalk8__default.default.yellow : chalk8__default.default.dim;
+          console.log(
+            chalk8__default.default.dim(`  ${arrow}`),
+            opColor(file.operation.padEnd(7)),
+            file.path,
+            chalk8__default.default.dim(`(${formatBytes(file.size || 0)})`)
+          );
+        }
+        if (plan.files.length > 10) {
+          console.log(chalk8__default.default.dim(`  ... and ${plan.files.length - 10} more files`));
+        }
+        console.log(chalk8__default.default.dim(`
+Total: ${plan.totalFiles} files (${formatBytes(plan.totalBytes)})`));
+        console.log(chalk8__default.default.dim("Run without --dry-run to execute sync."));
+        return;
+      }
+      console.log(chalk8__default.default.blue("Syncing...\n"));
+      const startTime = Date.now();
+      const result = await syncManager.executePlan(plan, syncOptions);
+      const duration = Date.now() - startTime;
+      console.log("");
+      if (result.success) {
+        console.log(chalk8__default.default.green(`\u2713 Sync completed successfully`));
+        console.log(chalk8__default.default.dim(`  Synced: ${result.synced} files`));
+        if (result.skipped > 0) {
+          console.log(chalk8__default.default.dim(`  Skipped: ${result.skipped} files`));
+        }
+        console.log(chalk8__default.default.dim(`  Duration: ${formatDuration(duration)}`));
       } else {
-        console.error(chalk6__default.default.red("Error:"), error.message);
+        console.log(chalk8__default.default.yellow(`\u26A0 Sync completed with errors`));
+        console.log(chalk8__default.default.green(`  Synced: ${result.synced} files`));
+        console.log(chalk8__default.default.red(`  Failed: ${result.failed} files`));
+        if (result.skipped > 0) {
+          console.log(chalk8__default.default.dim(`  Skipped: ${result.skipped} files`));
+        }
+        if (result.errors.length > 0) {
+          console.log("");
+          console.log(chalk8__default.default.red("Errors:"));
+          for (const error of result.errors.slice(0, 5)) {
+            console.log(chalk8__default.default.red(`  \u2022 ${error.path}: ${error.error}`));
+          }
+          if (result.errors.length > 5) {
+            console.log(chalk8__default.default.dim(`  ... and ${result.errors.length - 5} more errors`));
+          }
+        }
       }
+    } catch (error) {
+      console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
   return cmd;
 }
 
-// src/commands/sync/index.ts
-function syncCommand() {
-  const cmd = new commander.Command("sync");
-  cmd.description("Synchronize with codex repository");
-  cmd.addCommand(syncProjectCommand());
-  cmd.addCommand(syncOrgCommand());
-  return cmd;
-}
-
 // src/commands/types/index.ts
 init_cjs_shims();
 
@@ -1553,35 +1723,35 @@ function typesListCommand() {
         return;
       }
       if (types.length === 0) {
-        console.log(chalk6__default.default.yellow("No types found."));
+        console.log(chalk8__default.default.yellow("No types found."));
         return;
       }
-      console.log(chalk6__default.default.bold("Artifact Types\n"));
+      console.log(chalk8__default.default.bold("Artifact Types\n"));
       const builtinTypes = types.filter((t) => registry.isBuiltIn(t.name));
       const customTypes = types.filter((t) => !registry.isBuiltIn(t.name));
       if (builtinTypes.length > 0 && !options.customOnly) {
-        console.log(chalk6__default.default.bold("Built-in Types"));
-        console.log(chalk6__default.default.dim("\u2500".repeat(70)));
+        console.log(chalk8__default.default.bold("Built-in Types"));
+        console.log(chalk8__default.default.dim("\u2500".repeat(70)));
         for (const type of builtinTypes) {
           const patternStr = type.patterns[0] || "";
-          console.log(`  ${chalk6__default.default.cyan(type.name.padEnd(12))} ${patternStr.padEnd(30)} ${chalk6__default.default.dim(`TTL: ${formatTtl(type.defaultTtl)}`)}`);
-          console.log(`  ${chalk6__default.default.dim(" ".repeat(12) + type.description)}`);
+          console.log(`  ${chalk8__default.default.cyan(type.name.padEnd(12))} ${patternStr.padEnd(30)} ${chalk8__default.default.dim(`TTL: ${formatTtl(type.defaultTtl)}`)}`);
+          console.log(`  ${chalk8__default.default.dim(" ".repeat(12) + type.description)}`);
         }
         console.log("");
       }
       if (customTypes.length > 0 && !options.builtinOnly) {
-        console.log(chalk6__default.default.bold("Custom Types"));
-        console.log(chalk6__default.default.dim("\u2500".repeat(70)));
+        console.log(chalk8__default.default.bold("Custom Types"));
+        console.log(chalk8__default.default.dim("\u2500".repeat(70)));
         for (const type of customTypes) {
           const patternStr = type.patterns[0] || "";
-          console.log(`  ${chalk6__default.default.green(type.name.padEnd(12))} ${patternStr.padEnd(30)} ${chalk6__default.default.dim(`TTL: ${formatTtl(type.defaultTtl)}`)}`);
-          console.log(`  ${chalk6__default.default.dim(" ".repeat(12) + type.description)}`);
+          console.log(`  ${chalk8__default.default.green(type.name.padEnd(12))} ${patternStr.padEnd(30)} ${chalk8__default.default.dim(`TTL: ${formatTtl(type.defaultTtl)}`)}`);
+          console.log(`  ${chalk8__default.default.dim(" ".repeat(12) + type.description)}`);
         }
         console.log("");
       }
-      console.log(chalk6__default.default.dim(`Total: ${types.length} types (${builtinTypes.length} built-in, ${customTypes.length} custom)`));
+      console.log(chalk8__default.default.dim(`Total: ${types.length} types (${builtinTypes.length} built-in, ${customTypes.length} custom)`));
     } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
+      console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
@@ -1603,643 +1773,236 @@ function typesShowCommand() {
       const client = await getClient();
       const registry = client.getTypeRegistry();
       const type = registry.get(name);
-      if (!type) {
-        console.error(chalk6__default.default.red("Error:"), `Type "${name}" not found.`);
-        console.log(chalk6__default.default.dim('Run "fractary codex types list" to see available types.'));
-        process.exit(1);
-      }
-      const isBuiltin = registry.isBuiltIn(name);
-      if (options.json) {
-        console.log(JSON.stringify({
-          name: type.name,
-          builtin: isBuiltin,
-          description: type.description,
-          patterns: type.patterns,
-          defaultTtl: type.defaultTtl,
-          ttl: formatTtl2(type.defaultTtl),
-          archiveAfterDays: type.archiveAfterDays,
-          archiveStorage: type.archiveStorage,
-          syncPatterns: type.syncPatterns,
-          excludePatterns: type.excludePatterns
-        }, null, 2));
-        return;
-      }
-      const nameColor = isBuiltin ? chalk6__default.default.cyan : chalk6__default.default.green;
-      console.log(chalk6__default.default.bold(`Type: ${nameColor(name)}
-`));
-      console.log(`  ${chalk6__default.default.dim("Source:")}      ${isBuiltin ? "Built-in" : "Custom"}`);
-      console.log(`  ${chalk6__default.default.dim("Description:")} ${type.description}`);
-      console.log(`  ${chalk6__default.default.dim("TTL:")}         ${formatTtl2(type.defaultTtl)} (${type.defaultTtl} seconds)`);
-      console.log("");
-      console.log(chalk6__default.default.bold("Patterns"));
-      for (const pattern of type.patterns) {
-        console.log(`  ${chalk6__default.default.dim("\u2022")} ${pattern}`);
-      }
-      if (type.archiveAfterDays !== null) {
-        console.log("");
-        console.log(chalk6__default.default.bold("Archive Settings"));
-        console.log(`  ${chalk6__default.default.dim("After:")}   ${type.archiveAfterDays} days`);
-        console.log(`  ${chalk6__default.default.dim("Storage:")} ${type.archiveStorage || "not set"}`);
-      }
-      if (type.syncPatterns && type.syncPatterns.length > 0) {
-        console.log("");
-        console.log(chalk6__default.default.bold("Sync Patterns"));
-        for (const pattern of type.syncPatterns) {
-          console.log(`  ${chalk6__default.default.dim("\u2022")} ${pattern}`);
-        }
-      }
-      if (type.excludePatterns && type.excludePatterns.length > 0) {
-        console.log("");
-        console.log(chalk6__default.default.bold("Exclude Patterns"));
-        for (const pattern of type.excludePatterns) {
-          console.log(`  ${chalk6__default.default.dim("\u2022")} ${pattern}`);
-        }
-      }
-    } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-
-// src/commands/types/add.ts
-init_cjs_shims();
-init_migrate_config();
-function isValidTypeName(name) {
-  return /^[a-z][a-z0-9-]*$/.test(name);
-}
-function parseTtl(ttl) {
-  const match = ttl.match(/^(\d+)([smhd])$/);
-  if (!match) {
-    throw new Error("Invalid TTL format");
-  }
-  const value = parseInt(match[1], 10);
-  const unit = match[2];
-  switch (unit) {
-    case "s":
-      return value;
-    case "m":
-      return value * 60;
-    case "h":
-      return value * 3600;
-    case "d":
-      return value * 86400;
-    default:
-      throw new Error("Unknown TTL unit");
-  }
-}
-function formatTtl3(seconds) {
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
-  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
-  return `${Math.floor(seconds / 86400)}d`;
-}
-function typesAddCommand() {
-  const cmd = new commander.Command("add");
-  cmd.description("Add a custom artifact type").argument("<name>", "Type name (lowercase, alphanumeric with hyphens)").requiredOption("--pattern <glob>", "File pattern (glob syntax)").option("--ttl <duration>", 'Cache TTL (e.g., "24h", "7d")', "24h").option("--description <text>", "Type description").option("--json", "Output as JSON").action(async (name, options) => {
-    try {
-      if (!isValidTypeName(name)) {
-        console.error(chalk6__default.default.red("Error:"), "Invalid type name.");
-        console.log(chalk6__default.default.dim("Type name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens."));
-        process.exit(1);
-      }
-      const client = await getClient();
-      const registry = client.getTypeRegistry();
-      if (registry.isBuiltIn(name)) {
-        console.error(chalk6__default.default.red("Error:"), `Cannot override built-in type "${name}".`);
-        const builtinNames = registry.list().filter((t) => registry.isBuiltIn(t.name)).map((t) => t.name);
-        console.log(chalk6__default.default.dim("Built-in types: " + builtinNames.join(", ")));
-        process.exit(1);
-      }
-      if (registry.has(name)) {
-        console.error(chalk6__default.default.red("Error:"), `Custom type "${name}" already exists.`);
-        console.log(chalk6__default.default.dim('Use "fractary codex types remove" first to remove it.'));
-        process.exit(1);
-      }
-      let ttlSeconds;
-      try {
-        ttlSeconds = parseTtl(options.ttl);
-      } catch {
-        console.error(chalk6__default.default.red("Error:"), "Invalid TTL format.");
-        console.log(chalk6__default.default.dim("Expected format: <number><unit> where unit is s (seconds), m (minutes), h (hours), or d (days)"));
-        console.log(chalk6__default.default.dim("Examples: 30m, 24h, 7d"));
-        process.exit(1);
-      }
-      const configPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
-      const config = await readYamlConfig(configPath);
-      if (!config.types) {
-        config.types = { custom: {} };
-      }
-      if (!config.types.custom) {
-        config.types.custom = {};
-      }
-      config.types.custom[name] = {
-        description: options.description || `Custom type: ${name}`,
-        patterns: [options.pattern],
-        defaultTtl: ttlSeconds
-      };
-      await writeYamlConfig(config, configPath);
-      if (options.json) {
-        console.log(JSON.stringify({
-          success: true,
-          type: {
-            name,
-            description: config.types.custom[name].description,
-            patterns: config.types.custom[name].patterns,
-            defaultTtl: ttlSeconds,
-            ttl: formatTtl3(ttlSeconds),
-            builtin: false
-          },
-          message: "Custom type added successfully. Changes will take effect on next CLI invocation."
-        }, null, 2));
-        return;
-      }
-      console.log(chalk6__default.default.green("\u2713"), `Added custom type "${chalk6__default.default.cyan(name)}"`);
-      console.log("");
-      console.log(`  ${chalk6__default.default.dim("Pattern:")}     ${options.pattern}`);
-      console.log(`  ${chalk6__default.default.dim("TTL:")}         ${formatTtl3(ttlSeconds)} (${ttlSeconds} seconds)`);
-      if (options.description) {
-        console.log(`  ${chalk6__default.default.dim("Description:")} ${options.description}`);
-      }
-      console.log("");
-      console.log(chalk6__default.default.dim("Note: Custom type will be available on next CLI invocation."));
-    } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
-      if (error.message.includes("Failed to load configuration")) {
-        console.log(chalk6__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
-      }
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-
-// src/commands/types/remove.ts
-init_cjs_shims();
-init_migrate_config();
-function typesRemoveCommand() {
-  const cmd = new commander.Command("remove");
-  cmd.description("Remove a custom artifact type").argument("<name>", "Type name to remove").option("--json", "Output as JSON").option("--force", "Skip confirmation").action(async (name, options) => {
-    try {
-      const client = await getClient();
-      const registry = client.getTypeRegistry();
-      if (registry.isBuiltIn(name)) {
-        console.error(chalk6__default.default.red("Error:"), `Cannot remove built-in type "${name}".`);
-        console.log(chalk6__default.default.dim("Built-in types are permanent and cannot be removed."));
-        process.exit(1);
-      }
-      if (!registry.has(name)) {
-        console.error(chalk6__default.default.red("Error:"), `Custom type "${name}" not found.`);
-        console.log(chalk6__default.default.dim('Run "fractary codex types list --custom-only" to see custom types.'));
-        process.exit(1);
-      }
-      const typeInfo = registry.get(name);
-      const configPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
-      const config = await readYamlConfig(configPath);
-      if (!config.types?.custom?.[name]) {
-        console.error(chalk6__default.default.red("Error:"), `Custom type "${name}" not found in configuration.`);
-        process.exit(1);
-      }
-      delete config.types.custom[name];
-      if (Object.keys(config.types.custom).length === 0) {
-        delete config.types.custom;
-      }
-      if (config.types && Object.keys(config.types).length === 0) {
-        delete config.types;
-      }
-      await writeYamlConfig(config, configPath);
-      if (options.json) {
-        console.log(JSON.stringify({
-          success: true,
-          removed: {
-            name: typeInfo.name,
-            description: typeInfo.description,
-            patterns: typeInfo.patterns,
-            defaultTtl: typeInfo.defaultTtl
-          },
-          message: "Custom type removed successfully. Changes will take effect on next CLI invocation."
-        }, null, 2));
-        return;
-      }
-      console.log(chalk6__default.default.green("\u2713"), `Removed custom type "${chalk6__default.default.cyan(name)}"`);
-      console.log("");
-      console.log(chalk6__default.default.dim("Removed configuration:"));
-      console.log(`  ${chalk6__default.default.dim("Pattern:")}     ${typeInfo.patterns.join(", ")}`);
-      console.log(`  ${chalk6__default.default.dim("Description:")} ${typeInfo.description}`);
-      console.log("");
-      console.log(chalk6__default.default.dim("Note: Custom type will be removed on next CLI invocation."));
-    } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
-      if (error.message.includes("Failed to load configuration")) {
-        console.log(chalk6__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
-      }
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-
-// src/commands/types/index.ts
-function typesCommand() {
-  const cmd = new commander.Command("types");
-  cmd.description("Manage artifact type registry");
-  cmd.addCommand(typesListCommand());
-  cmd.addCommand(typesShowCommand());
-  cmd.addCommand(typesAddCommand());
-  cmd.addCommand(typesRemoveCommand());
-  return cmd;
-}
-
-// src/commands/health.ts
-init_cjs_shims();
-init_migrate_config();
-async function fileExists2(filePath) {
-  try {
-    await fs__namespace.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function checkConfiguration() {
-  const configPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
-  const legacyConfigPath = path2__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
-  try {
-    if (!await fileExists2(configPath)) {
-      if (await fileExists2(legacyConfigPath)) {
-        return {
-          name: "Configuration",
-          status: "warn",
-          message: "Legacy JSON configuration detected",
-          details: 'Run "fractary codex migrate" to upgrade to YAML format'
-        };
-      }
-      return {
-        name: "Configuration",
-        status: "fail",
-        message: "No configuration found",
-        details: 'Run "fractary codex init" to create configuration'
-      };
-    }
-    const config = await readYamlConfig(configPath);
-    if (!config.organization) {
-      return {
-        name: "Configuration",
-        status: "warn",
-        message: "No organization configured",
-        details: "Organization slug is required"
-      };
-    }
-    const providerCount = config.storage?.length || 0;
-    if (providerCount === 0) {
-      return {
-        name: "Configuration",
-        status: "warn",
-        message: "No storage providers configured",
-        details: "At least one storage provider is recommended"
-      };
-    }
-    return {
-      name: "Configuration",
-      status: "pass",
-      message: "Valid YAML configuration",
-      details: `Organization: ${config.organization}, ${providerCount} storage provider(s)`
-    };
-  } catch (error) {
-    return {
-      name: "Configuration",
-      status: "fail",
-      message: "Invalid configuration",
-      details: error.message
-    };
-  }
-}
-async function checkSDKClient() {
-  try {
-    const client = await getClient();
-    const organization = client.getOrganization();
-    return {
-      name: "SDK Client",
-      status: "pass",
-      message: "CodexClient initialized successfully",
-      details: `Organization: ${organization}`
-    };
-  } catch (error) {
-    return {
-      name: "SDK Client",
-      status: "fail",
-      message: "Failed to initialize CodexClient",
-      details: error.message
-    };
-  }
-}
-async function checkCache() {
-  try {
-    const client = await getClient();
-    const stats = await client.getCacheStats();
-    if (stats.entryCount === 0) {
-      return {
-        name: "Cache",
-        status: "warn",
-        message: "Cache is empty",
-        details: "Fetch some documents to populate cache"
-      };
-    }
-    const healthPercent = stats.entryCount > 0 ? stats.freshCount / stats.entryCount * 100 : 100;
-    if (healthPercent < 50) {
-      return {
-        name: "Cache",
-        status: "warn",
-        message: `${stats.entryCount} entries (${healthPercent.toFixed(0)}% fresh)`,
-        details: `${stats.expiredCount} expired, ${stats.staleCount} stale`
-      };
-    }
-    return {
-      name: "Cache",
-      status: "pass",
-      message: `${stats.entryCount} entries (${healthPercent.toFixed(0)}% fresh)`,
-      details: `${formatSize4(stats.totalSize)} total`
-    };
-  } catch (error) {
-    return {
-      name: "Cache",
-      status: "fail",
-      message: "Cache check failed",
-      details: error.message
-    };
-  }
-}
-async function checkStorage() {
-  const configPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
-  try {
-    const config = await readYamlConfig(configPath);
-    const providers = config.storage || [];
-    if (providers.length === 0) {
-      return {
-        name: "Storage",
-        status: "warn",
-        message: "No storage providers configured",
-        details: "Configure at least one provider in .fractary/codex.yaml"
-      };
-    }
-    const providerTypes = providers.map((p) => p.type).join(", ");
-    const hasGitHub = providers.some((p) => p.type === "github");
-    if (hasGitHub && !process.env.GITHUB_TOKEN) {
-      return {
-        name: "Storage",
-        status: "warn",
-        message: `${providers.length} provider(s): ${providerTypes}`,
-        details: "GITHUB_TOKEN not set (required for GitHub provider)"
-      };
-    }
-    return {
-      name: "Storage",
-      status: "pass",
-      message: `${providers.length} provider(s): ${providerTypes}`,
-      details: "All configured providers available"
-    };
-  } catch (error) {
-    return {
-      name: "Storage",
-      status: "fail",
-      message: "Storage check failed",
-      details: error.message
-    };
-  }
-}
-async function checkTypes() {
-  try {
-    const client = await getClient();
-    const registry = client.getTypeRegistry();
-    const allTypes = registry.list();
-    const builtinCount = allTypes.filter((t) => registry.isBuiltIn(t.name)).length;
-    const customCount = allTypes.length - builtinCount;
-    return {
-      name: "Type Registry",
-      status: "pass",
-      message: `${allTypes.length} types registered`,
-      details: `${builtinCount} built-in, ${customCount} custom`
-    };
-  } catch (error) {
-    return {
-      name: "Type Registry",
-      status: "fail",
-      message: "Type registry check failed",
-      details: error.message
-    };
-  }
-}
-function formatSize4(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-function healthCommand() {
-  const cmd = new commander.Command("health");
-  cmd.description("Run diagnostics on codex setup").option("--json", "Output as JSON").action(async (options) => {
-    try {
-      const checks = [];
-      checks.push(await checkConfiguration());
-      checks.push(await checkSDKClient());
-      checks.push(await checkCache());
-      checks.push(await checkStorage());
-      checks.push(await checkTypes());
-      const passed = checks.filter((c) => c.status === "pass").length;
-      const warned = checks.filter((c) => c.status === "warn").length;
-      const failed = checks.filter((c) => c.status === "fail").length;
+      if (!type) {
+        console.error(chalk8__default.default.red("Error:"), `Type "${name}" not found.`);
+        console.log(chalk8__default.default.dim('Run "fractary codex types list" to see available types.'));
+        process.exit(1);
+      }
+      const isBuiltin = registry.isBuiltIn(name);
       if (options.json) {
         console.log(JSON.stringify({
-          summary: {
-            total: checks.length,
-            passed,
-            warned,
-            failed,
-            healthy: failed === 0
-          },
-          checks
+          name: type.name,
+          builtin: isBuiltin,
+          description: type.description,
+          patterns: type.patterns,
+          defaultTtl: type.defaultTtl,
+          ttl: formatTtl2(type.defaultTtl),
+          archiveAfterDays: type.archiveAfterDays,
+          archiveStorage: type.archiveStorage,
+          syncPatterns: type.syncPatterns,
+          excludePatterns: type.excludePatterns
         }, null, 2));
         return;
       }
-      console.log(chalk6__default.default.bold("Codex Health Check\n"));
-      for (const check of checks) {
-        const icon = check.status === "pass" ? chalk6__default.default.green("\u2713") : check.status === "warn" ? chalk6__default.default.yellow("\u26A0") : chalk6__default.default.red("\u2717");
-        const statusColor = check.status === "pass" ? chalk6__default.default.green : check.status === "warn" ? chalk6__default.default.yellow : chalk6__default.default.red;
-        console.log(`${icon} ${chalk6__default.default.bold(check.name)}`);
-        console.log(`  ${statusColor(check.message)}`);
-        if (check.details) {
-          console.log(`  ${chalk6__default.default.dim(check.details)}`);
-        }
+      const nameColor = isBuiltin ? chalk8__default.default.cyan : chalk8__default.default.green;
+      console.log(chalk8__default.default.bold(`Type: ${nameColor(name)}
+`));
+      console.log(`  ${chalk8__default.default.dim("Source:")}      ${isBuiltin ? "Built-in" : "Custom"}`);
+      console.log(`  ${chalk8__default.default.dim("Description:")} ${type.description}`);
+      console.log(`  ${chalk8__default.default.dim("TTL:")}         ${formatTtl2(type.defaultTtl)} (${type.defaultTtl} seconds)`);
+      console.log("");
+      console.log(chalk8__default.default.bold("Patterns"));
+      for (const pattern of type.patterns) {
+        console.log(`  ${chalk8__default.default.dim("\u2022")} ${pattern}`);
+      }
+      if (type.archiveAfterDays !== null) {
         console.log("");
+        console.log(chalk8__default.default.bold("Archive Settings"));
+        console.log(`  ${chalk8__default.default.dim("After:")}   ${type.archiveAfterDays} days`);
+        console.log(`  ${chalk8__default.default.dim("Storage:")} ${type.archiveStorage || "not set"}`);
       }
-      console.log(chalk6__default.default.dim("\u2500".repeat(60)));
-      const overallStatus = failed > 0 ? chalk6__default.default.red("UNHEALTHY") : warned > 0 ? chalk6__default.default.yellow("DEGRADED") : chalk6__default.default.green("HEALTHY");
-      console.log(`Status: ${overallStatus}`);
-      console.log(chalk6__default.default.dim(`${passed} passed, ${warned} warnings, ${failed} failed`));
-      if (failed > 0 || warned > 0) {
+      if (type.syncPatterns && type.syncPatterns.length > 0) {
         console.log("");
-        console.log(chalk6__default.default.dim("Run checks individually for more details:"));
-        console.log(chalk6__default.default.dim("  fractary codex cache stats"));
-        console.log(chalk6__default.default.dim("  fractary codex types list"));
+        console.log(chalk8__default.default.bold("Sync Patterns"));
+        for (const pattern of type.syncPatterns) {
+          console.log(`  ${chalk8__default.default.dim("\u2022")} ${pattern}`);
+        }
       }
-      if (failed > 0) {
-        process.exit(1);
+      if (type.excludePatterns && type.excludePatterns.length > 0) {
+        console.log("");
+        console.log(chalk8__default.default.bold("Exclude Patterns"));
+        for (const pattern of type.excludePatterns) {
+          console.log(`  ${chalk8__default.default.dim("\u2022")} ${pattern}`);
+        }
       }
     } catch (error) {
-      console.error(chalk6__default.default.red("Error:"), error.message);
+      console.error(chalk8__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
   return cmd;
 }
 
-// src/commands/migrate.ts
+// src/commands/types/add.ts
 init_cjs_shims();
 init_migrate_config();
-async function fileExists3(filePath) {
-  try {
-    await fs__namespace.access(filePath);
-    return true;
-  } catch {
-    return false;
+function isValidTypeName(name) {
+  return /^[a-z][a-z0-9-]*$/.test(name);
+}
+function parseTtl(ttl) {
+  const match = ttl.match(/^(\d+)([smhd])$/);
+  if (!match) {
+    throw new Error("Invalid TTL format");
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value;
+    case "m":
+      return value * 60;
+    case "h":
+      return value * 3600;
+    case "d":
+      return value * 86400;
+    default:
+      throw new Error("Unknown TTL unit");
   }
 }
-async function readFileContent(filePath) {
-  return fs__namespace.readFile(filePath, "utf-8");
+function formatTtl3(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
 }
-function migrateCommand() {
-  const cmd = new commander.Command("migrate");
-  cmd.description("Migrate legacy JSON configuration to v3.0 YAML format").option("--dry-run", "Show migration plan without executing").option("--no-backup", "Skip creating backup of old config").option("--json", "Output as JSON").action(async (options) => {
+function typesAddCommand() {
+  const cmd = new commander.Command("add");
+  cmd.description("Add a custom artifact type").argument("<name>", "Type name (lowercase, alphanumeric with hyphens)").requiredOption("--pattern <glob>", "File pattern (glob syntax)").option("--ttl <duration>", 'Cache TTL (e.g., "24h", "7d")', "24h").option("--description <text>", "Type description").option("--json", "Output as JSON").action(async (name, options) => {
     try {
-      const legacyConfigPath = path2__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
-      const newConfigPath = path2__namespace.join(process.cwd(), ".fractary", "codex.yaml");
-      if (!await fileExists3(legacyConfigPath)) {
-        if (options.json) {
-          console.log(JSON.stringify({
-            status: "no_config",
-            message: "No legacy configuration file found",
-            path: legacyConfigPath
-          }));
-        } else {
-          console.log(chalk6__default.default.yellow("\u26A0 No legacy configuration file found."));
-          console.log(chalk6__default.default.dim(`  Expected: ${legacyConfigPath}`));
-          console.log(chalk6__default.default.dim('\nRun "fractary codex init" to create a new v3.0 YAML configuration.'));
-        }
-        return;
+      if (!isValidTypeName(name)) {
+        console.error(chalk8__default.default.red("Error:"), "Invalid type name.");
+        console.log(chalk8__default.default.dim("Type name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens."));
+        process.exit(1);
       }
-      if (await fileExists3(newConfigPath) && !options.dryRun) {
-        if (options.json) {
-          console.log(JSON.stringify({
-            status: "already_migrated",
-            message: "YAML configuration already exists",
-            path: newConfigPath
-          }));
-        } else {
-          console.log(chalk6__default.default.yellow("\u26A0 YAML configuration already exists."));
-          console.log(chalk6__default.default.dim(`  Path: ${newConfigPath}`));
-          console.log(chalk6__default.default.dim('\nUse "fractary codex init --force" to recreate.'));
-        }
-        return;
+      const client = await getClient();
+      const registry = client.getTypeRegistry();
+      if (registry.isBuiltIn(name)) {
+        console.error(chalk8__default.default.red("Error:"), `Cannot override built-in type "${name}".`);
+        const builtinNames = registry.list().filter((t) => registry.isBuiltIn(t.name)).map((t) => t.name);
+        console.log(chalk8__default.default.dim("Built-in types: " + builtinNames.join(", ")));
+        process.exit(1);
       }
-      const legacyContent = await readFileContent(legacyConfigPath);
-      let legacyConfig;
+      if (registry.has(name)) {
+        console.error(chalk8__default.default.red("Error:"), `Custom type "${name}" already exists.`);
+        console.log(chalk8__default.default.dim('Use "fractary codex types remove" first to remove it.'));
+        process.exit(1);
+      }
+      let ttlSeconds;
       try {
-        legacyConfig = JSON.parse(legacyContent);
+        ttlSeconds = parseTtl(options.ttl);
       } catch {
-        console.error(chalk6__default.default.red("Error:"), "Invalid JSON in legacy config file.");
+        console.error(chalk8__default.default.red("Error:"), "Invalid TTL format.");
+        console.log(chalk8__default.default.dim("Expected format: <number><unit> where unit is s (seconds), m (minutes), h (hours), or d (days)"));
+        console.log(chalk8__default.default.dim("Examples: 30m, 24h, 7d"));
         process.exit(1);
       }
-      if (!options.json && !options.dryRun) {
-        console.log(chalk6__default.default.blue("Migrating Codex configuration to v3.0 YAML format...\n"));
+      const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex.yaml");
+      const config = await readYamlConfig(configPath);
+      if (!config.types) {
+        config.types = { custom: {} };
       }
-      const migrationResult = await migrateConfig(
-        legacyConfigPath,
-        {
-          createBackup: options.backup !== false,
-          backupSuffix: (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")
-        }
-      );
-      if (!options.json) {
-        console.log(chalk6__default.default.bold("Legacy Configuration:"));
-        console.log(chalk6__default.default.dim(`  Path: ${legacyConfigPath}`));
-        console.log(chalk6__default.default.dim(`  Organization: ${legacyConfig.organization || legacyConfig.organizationSlug || "unknown"}`));
-        console.log("");
-        console.log(chalk6__default.default.bold("Migration Changes:"));
-        console.log(chalk6__default.default.green("  + Format: JSON \u2192 YAML"));
-        console.log(chalk6__default.default.green("  + Location: .fractary/plugins/codex/ \u2192 .fractary/"));
-        console.log(chalk6__default.default.green("  + File: config.json \u2192 codex.yaml"));
-        console.log(chalk6__default.default.green("  + Storage: Multi-provider configuration"));
-        console.log(chalk6__default.default.green("  + Cache: Modern cache management"));
-        console.log(chalk6__default.default.green("  + Types: Custom type registry"));
-        if (migrationResult.warnings.length > 0) {
-          console.log("");
-          console.log(chalk6__default.default.yellow("Warnings:"));
-          for (const warning of migrationResult.warnings) {
-            console.log(chalk6__default.default.yellow("  \u26A0"), chalk6__default.default.dim(warning));
-          }
-        }
-        console.log("");
-        if (options.dryRun) {
-          console.log(chalk6__default.default.blue("Dry run - no changes made."));
-          console.log(chalk6__default.default.dim("Run without --dry-run to execute migration."));
-          return;
-        }
+      if (!config.types.custom) {
+        config.types.custom = {};
       }
+      config.types.custom[name] = {
+        description: options.description || `Custom type: ${name}`,
+        patterns: [options.pattern],
+        defaultTtl: ttlSeconds
+      };
+      await writeYamlConfig(config, configPath);
       if (options.json) {
-        const output = {
-          status: options.dryRun ? "migration_ready" : "migrated",
-          dryRun: options.dryRun || false,
-          legacyConfig: {
-            path: legacyConfigPath,
-            organization: legacyConfig.organization || legacyConfig.organizationSlug
-          },
-          newConfig: {
-            path: newConfigPath,
-            organization: migrationResult.yamlConfig.organization
+        console.log(JSON.stringify({
+          success: true,
+          type: {
+            name,
+            description: config.types.custom[name].description,
+            patterns: config.types.custom[name].patterns,
+            defaultTtl: ttlSeconds,
+            ttl: formatTtl3(ttlSeconds),
+            builtin: false
           },
-          warnings: migrationResult.warnings,
-          backupPath: migrationResult.backupPath
-        };
-        console.log(JSON.stringify(output, null, 2));
-        if (options.dryRun) {
-          return;
-        }
+          message: "Custom type added successfully. Changes will take effect on next CLI invocation."
+        }, null, 2));
+        return;
       }
-      if (!options.dryRun) {
-        await writeYamlConfig(migrationResult.yamlConfig, newConfigPath);
-        const cacheDir = path2__namespace.join(process.cwd(), ".codex-cache");
-        await fs__namespace.mkdir(cacheDir, { recursive: true });
-        if (!options.json) {
-          console.log(chalk6__default.default.green("\u2713"), "YAML configuration created");
-          console.log(chalk6__default.default.green("\u2713"), "Cache directory initialized");
-          if (migrationResult.backupPath) {
-            console.log(chalk6__default.default.green("\u2713"), "Legacy config backed up");
-          }
-          console.log("");
-          console.log(chalk6__default.default.bold("New Configuration:"));
-          console.log(chalk6__default.default.dim(`  Path: ${newConfigPath}`));
-          console.log(chalk6__default.default.dim(`  Organization: ${migrationResult.yamlConfig.organization}`));
-          console.log(chalk6__default.default.dim(`  Cache: ${migrationResult.yamlConfig.cacheDir || ".codex-cache"}`));
-          console.log(chalk6__default.default.dim(`  Storage Providers: ${migrationResult.yamlConfig.storage?.length || 0}`));
-          console.log("");
-          console.log(chalk6__default.default.bold("Next Steps:"));
-          console.log(chalk6__default.default.dim("  1. Review the new configuration: .fractary/codex.yaml"));
-          console.log(chalk6__default.default.dim('  2. Set your GitHub token: export GITHUB_TOKEN="your_token"'));
-          console.log(chalk6__default.default.dim("  3. Test fetching: fractary codex fetch codex://org/project/path"));
-          if (migrationResult.backupPath) {
-            console.log("");
-            console.log(chalk6__default.default.dim(`Backup saved: ${path2__namespace.basename(migrationResult.backupPath)}`));
-          }
-        }
+      console.log(chalk8__default.default.green("\u2713"), `Added custom type "${chalk8__default.default.cyan(name)}"`);
+      console.log("");
+      console.log(`  ${chalk8__default.default.dim("Pattern:")}     ${options.pattern}`);
+      console.log(`  ${chalk8__default.default.dim("TTL:")}         ${formatTtl3(ttlSeconds)} (${ttlSeconds} seconds)`);
+      if (options.description) {
+        console.log(`  ${chalk8__default.default.dim("Description:")} ${options.description}`);
       }
+      console.log("");
+      console.log(chalk8__default.default.dim("Note: Custom type will be available on next CLI invocation."));
     } catch (error) {
+      console.error(chalk8__default.default.red("Error:"), error.message);
+      if (error.message.includes("Failed to load configuration")) {
+        console.log(chalk8__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
+      }
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/types/remove.ts
+init_cjs_shims();
+init_migrate_config();
+function typesRemoveCommand() {
+  const cmd = new commander.Command("remove");
+  cmd.description("Remove a custom artifact type").argument("<name>", "Type name to remove").option("--json", "Output as JSON").option("--force", "Skip confirmation").action(async (name, options) => {
+    try {
+      const client = await getClient();
+      const registry = client.getTypeRegistry();
+      if (registry.isBuiltIn(name)) {
+        console.error(chalk8__default.default.red("Error:"), `Cannot remove built-in type "${name}".`);
+        console.log(chalk8__default.default.dim("Built-in types are permanent and cannot be removed."));
+        process.exit(1);
+      }
+      if (!registry.has(name)) {
+        console.error(chalk8__default.default.red("Error:"), `Custom type "${name}" not found.`);
+        console.log(chalk8__default.default.dim('Run "fractary codex types list --custom-only" to see custom types.'));
+        process.exit(1);
+      }
+      const typeInfo = registry.get(name);
+      const configPath = path3__namespace.join(process.cwd(), ".fractary", "codex.yaml");
+      const config = await readYamlConfig(configPath);
+      if (!config.types?.custom?.[name]) {
+        console.error(chalk8__default.default.red("Error:"), `Custom type "${name}" not found in configuration.`);
+        process.exit(1);
+      }
+      delete config.types.custom[name];
+      if (Object.keys(config.types.custom).length === 0) {
+        delete config.types.custom;
+      }
+      if (config.types && Object.keys(config.types).length === 0) {
+        delete config.types;
+      }
+      await writeYamlConfig(config, configPath);
       if (options.json) {
         console.log(JSON.stringify({
-          status: "error",
-          message: error.message
-        }));
-      } else {
-        console.error(chalk6__default.default.red("Error:"), error.message);
+          success: true,
+          removed: {
+            name: typeInfo.name,
+            description: typeInfo.description,
+            patterns: typeInfo.patterns,
+            defaultTtl: typeInfo.defaultTtl
+          },
+          message: "Custom type removed successfully. Changes will take effect on next CLI invocation."
+        }, null, 2));
+        return;
+      }
+      console.log(chalk8__default.default.green("\u2713"), `Removed custom type "${chalk8__default.default.cyan(name)}"`);
+      console.log("");
+      console.log(chalk8__default.default.dim("Removed configuration:"));
+      console.log(`  ${chalk8__default.default.dim("Pattern:")}     ${typeInfo.patterns.join(", ")}`);
+      console.log(`  ${chalk8__default.default.dim("Description:")} ${typeInfo.description}`);
+      console.log("");
+      console.log(chalk8__default.default.dim("Note: Custom type will be removed on next CLI invocation."));
+    } catch (error) {
+      console.error(chalk8__default.default.red("Error:"), error.message);
+      if (error.message.includes("Failed to load configuration")) {
+        console.log(chalk8__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
       }
       process.exit(1);
     }
@@ -2247,17 +2010,26 @@ function migrateCommand() {
   return cmd;
 }
 
+// src/commands/types/index.ts
+function typesCommand() {
+  const cmd = new commander.Command("types");
+  cmd.description("Manage artifact type registry");
+  cmd.addCommand(typesListCommand());
+  cmd.addCommand(typesShowCommand());
+  cmd.addCommand(typesAddCommand());
+  cmd.addCommand(typesRemoveCommand());
+  return cmd;
+}
+
 // src/cli.ts
 function createCLI() {
   const program = new commander.Command("fractary-codex");
-  program.description("Centralized knowledge management and distribution for AI agents").version("0.2.0");
-  program.addCommand(initCommand());
-  program.addCommand(fetchCommand());
+  program.description("Centralized knowledge management and distribution for AI agents").version("0.3.0");
+  program.addCommand(documentCommand());
+  program.addCommand(configCommand());
   program.addCommand(cacheCommand());
   program.addCommand(syncCommand());
   program.addCommand(typesCommand());
-  program.addCommand(healthCommand());
-  program.addCommand(migrateCommand());
   return program;
 }
 async function main() {