@fractary/codex-cli 0.10.15 → 0.10.19

package/dist/cli.cjs

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 'use strict';
 
-var fs$1 = require('fs/promises');
-var path4 = require('path');
-var yaml2 = require('js-yaml');
 var codex = require('@fractary/codex');
+var path3 = require('path');
 var os = require('os');
+var fs2 = require('fs/promises');
 var child_process = require('child_process');
 var commander = require('commander');
-var chalk7 = require('chalk');
+var chalk10 = require('chalk');
 var crypto = require('crypto');
+require('js-yaml');
 var fs = require('fs');
 var url = require('url');
 
@@ -33,21 +33,14 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs$1);
-var path4__namespace = /*#__PURE__*/_interopNamespace(path4);
-var yaml2__namespace = /*#__PURE__*/_interopNamespace(yaml2);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
-var chalk7__default = /*#__PURE__*/_interopDefault(chalk7);
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
+var chalk10__default = /*#__PURE__*/_interopDefault(chalk10);
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -65,477 +58,19 @@ var init_cjs_shims = __esm({
   }
 });
 
-// src/config/migrate-config.ts
-var migrate_config_exports = {};
-__export(migrate_config_exports, {
-  getDefaultYamlConfig: () => getDefaultYamlConfig,
-  isLegacyConfig: () => isLegacyConfig,
-  migrateConfig: () => migrateConfig,
-  readYamlConfig: () => codex.readCodexConfig,
-  writeYamlConfig: () => writeYamlConfig
-});
-async function isLegacyConfig(configPath) {
-  try {
-    const content = await fs__namespace.readFile(configPath, "utf-8");
-    const config = JSON.parse(content);
-    return config.version === "3.0" || config.organizationSlug !== void 0 || config.directories !== void 0 || config.rules !== void 0;
-  } catch {
-    return false;
-  }
-}
-async function migrateConfig(legacyConfigPath, options) {
-  const warnings = [];
-  try {
-    const content = await fs__namespace.readFile(legacyConfigPath, "utf-8");
-    const legacy = JSON.parse(content);
-    let backupPath;
-    if (options?.createBackup !== false) {
-      const suffix = options?.backupSuffix || (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      backupPath = `${legacyConfigPath}.backup-${suffix}`;
-      await fs__namespace.writeFile(backupPath, content, "utf-8");
-    }
-    const yamlConfig = {
-      organization: legacy.organization || legacy.organizationSlug || "default"
-    };
-    if (legacy.cache) {
-      yamlConfig.cacheDir = legacy.cache.directory || ".fractary/codex/cache";
-    }
-    if (legacy.storage?.providers) {
-      yamlConfig.storage = [];
-      for (const [type, config] of Object.entries(legacy.storage.providers)) {
-        if (type === "github") {
-          const githubConfig = config;
-          yamlConfig.storage.push({
-            type: "github",
-            token: githubConfig.token || "${GITHUB_TOKEN}",
-            apiBaseUrl: githubConfig.baseUrl || "https://api.github.com",
-            branch: githubConfig.branch || "main",
-            priority: 50
-          });
-        } else if (type === "http") {
-          const httpConfig = config;
-          yamlConfig.storage.push({
-            type: "http",
-            baseUrl: httpConfig.baseUrl,
-            headers: httpConfig.headers,
-            timeout: httpConfig.timeout || 3e4,
-            priority: 100
-          });
-        } else if (type === "local") {
-          const localConfig = config;
-          yamlConfig.storage.push({
-            type: "local",
-            basePath: localConfig.basePath || "./knowledge",
-            followSymlinks: localConfig.followSymlinks || false,
-            priority: 10
-          });
-        } else {
-          warnings.push(`Unknown storage provider type: ${type}`);
-        }
-      }
-      if (yamlConfig.storage.length === 0) {
-        yamlConfig.storage.push({
-          type: "github",
-          token: "${GITHUB_TOKEN}",
-          apiBaseUrl: "https://api.github.com",
-          branch: "main",
-          priority: 50
-        });
-        warnings.push("No storage providers found, added default GitHub provider");
-      }
-    }
-    if (legacy.types?.custom && Array.isArray(legacy.types.custom)) {
-      yamlConfig.types = {
-        custom: {}
-      };
-      for (const customType of legacy.types.custom) {
-        if (customType.name) {
-          yamlConfig.types.custom[customType.name] = {
-            description: customType.description,
-            patterns: customType.patterns || [],
-            defaultTtl: customType.defaultTtl,
-            archiveAfterDays: customType.archiveAfterDays,
-            archiveStorage: customType.archiveStorage
-          };
-        }
-      }
-    }
-    if (legacy.sync) {
-      yamlConfig.sync = {
-        bidirectional: true,
-        conflictResolution: "prompt",
-        exclude: [
-          "node_modules/**",
-          ".git/**",
-          "**/*.log",
-          ".env"
-        ]
-      };
-      if (legacy.sync.environments) {
-        warnings.push("Sync environments are not directly supported in v3.0 - please configure sync rules manually");
-      }
-    }
-    if (legacy.mcp) {
-      yamlConfig.mcp = {
-        enabled: legacy.mcp.enabled || false,
-        port: legacy.mcp.port || 3e3
-      };
-    }
-    return {
-      success: true,
-      yamlConfig,
-      warnings,
-      backupPath
-    };
-  } catch (error) {
-    throw new Error(
-      `Migration failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-async function writeYamlConfig(config, outputPath) {
-  const dir = path4__namespace.dirname(outputPath);
-  await fs__namespace.mkdir(dir, { recursive: true });
-  const yamlContent = yaml2__namespace.dump(config, {
-    indent: 2,
-    lineWidth: 80,
-    noRefs: true,
-    sortKeys: false
-  });
-  await fs__namespace.writeFile(outputPath, yamlContent, "utf-8");
-}
-function getDefaultYamlConfig(organization) {
-  return {
-    organization,
-    cacheDir: ".fractary/codex/cache",
-    storage: [
-      {
-        type: "local",
-        basePath: "./knowledge",
-        followSymlinks: false,
-        priority: 10
-      },
-      {
-        type: "github",
-        token: "${GITHUB_TOKEN}",
-        apiBaseUrl: "https://api.github.com",
-        branch: "main",
-        priority: 50
-      },
-      {
-        type: "http",
-        baseUrl: "https://codex.example.com",
-        timeout: 3e4,
-        priority: 100
-      }
-    ],
-    types: {
-      custom: {}
-    },
-    permissions: {
-      default: "read",
-      rules: [
-        {
-          pattern: "internal/**",
-          permission: "none"
-        },
-        {
-          pattern: "public/**",
-          permission: "read"
-        }
-      ]
-    },
-    sync: {
-      bidirectional: true,
-      conflictResolution: "prompt",
-      exclude: [
-        "node_modules/**",
-        ".git/**",
-        "**/*.log",
-        ".env"
-      ]
-    },
-    mcp: {
-      enabled: false,
-      port: 3e3
-    }
-  };
-}
-var init_migrate_config = __esm({
-  "src/config/migrate-config.ts"() {
-    init_cjs_shims();
-  }
-});
-
-// src/config/config-types.ts
-var config_types_exports = {};
-__export(config_types_exports, {
-  parseDuration: () => codex.parseDuration,
-  parseSize: () => codex.parseSize,
-  resolveEnvVars: () => codex.expandEnvVars,
-  resolveEnvVarsInConfig: () => codex.expandEnvVarsInConfig
-});
-var init_config_types = __esm({
-  "src/config/config-types.ts"() {
-    init_cjs_shims();
-  }
-});
-
 // src/client/codex-client.ts
 var codex_client_exports = {};
 __export(codex_client_exports, {
-  CodexClient: () => CodexClient,
+  CodexClient: () => codex.CodexClient,
   CodexError: () => codex.CodexError,
   ConfigurationError: () => codex.ConfigurationError,
   PermissionDeniedError: () => codex.PermissionDeniedError,
-  ValidationError: () => codex.ValidationError
+  ValidationError: () => codex.ValidationError,
+  createCodexClient: () => codex.createCodexClient
 });
-var CodexClient;
 var init_codex_client = __esm({
   "src/client/codex-client.ts"() {
     init_cjs_shims();
-    CodexClient = class _CodexClient {
-      cache;
-      storage;
-      types;
-      organization;
-      /**
-       * Private constructor - use CodexClient.create() instead
-       */
-      constructor(cache, storage, types, organization) {
-        this.cache = cache;
-        this.storage = storage;
-        this.types = types;
-        this.organization = organization;
-      }
-      /**
-       * Create a new CodexClient instance
-       *
-       * @param options - Optional configuration
-       * @returns Promise resolving to CodexClient instance
-       *
-       * @example
-       * ```typescript
-       * const client = await CodexClient.create();
-       * ```
-       */
-      static async create(options) {
-        const {
-          CacheManager,
-          createStorageManager,
-          createDefaultRegistry,
-          CodexError: CodexError2,
-          ConfigurationError: ConfigurationError2
-        } = await import('@fractary/codex');
-        const { readYamlConfig } = await Promise.resolve().then(() => (init_migrate_config(), migrate_config_exports));
-        const { resolveEnvVarsInConfig } = await Promise.resolve().then(() => (init_config_types(), config_types_exports));
-        try {
-          const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
-          let config;
-          try {
-            config = await readYamlConfig(configPath);
-            config = resolveEnvVarsInConfig(config);
-          } catch (error) {
-            throw new ConfigurationError2(
-              `Failed to load configuration from ${configPath}. Run "fractary codex init" to create a configuration.`
-            );
-          }
-          const organization = options?.organizationSlug || config.organization;
-          const cacheDir = options?.cacheDir || config.cacheDir || ".codex-cache";
-          const storageConfig = {};
-          if (config.storage && Array.isArray(config.storage)) {
-            for (const provider of config.storage) {
-              if (provider.type === "github") {
-                storageConfig.github = {
-                  token: provider.token || process.env.GITHUB_TOKEN,
-                  apiBaseUrl: provider.apiBaseUrl || "https://api.github.com",
-                  branch: provider.branch || "main"
-                };
-              } else if (provider.type === "http") {
-                storageConfig.http = {
-                  baseUrl: provider.baseUrl,
-                  headers: provider.headers,
-                  timeout: provider.timeout || 3e4
-                };
-              } else if (provider.type === "local") {
-                storageConfig.local = {
-                  basePath: provider.basePath || "./knowledge",
-                  followSymlinks: provider.followSymlinks || false
-                };
-              }
-            }
-          }
-          const storage = createStorageManager(storageConfig);
-          const cache = new CacheManager({
-            cacheDir,
-            defaultTtl: 86400,
-            // 24 hours
-            maxMemoryEntries: 100,
-            maxMemorySize: 50 * 1024 * 1024,
-            // 50MB
-            enablePersistence: true
-          });
-          cache.setStorageManager(storage);
-          const types = createDefaultRegistry();
-          if (config.types?.custom) {
-            for (const [name, customType] of Object.entries(config.types.custom)) {
-              const ct = customType;
-              types.register({
-                name,
-                description: ct.description || `Custom type: ${name}`,
-                patterns: ct.patterns || [],
-                defaultTtl: ct.defaultTtl || 86400,
-                archiveAfterDays: ct.archiveAfterDays !== void 0 ? ct.archiveAfterDays : null,
-                archiveStorage: ct.archiveStorage || null
-              });
-            }
-          }
-          return new _CodexClient(cache, storage, types, organization);
-        } catch (error) {
-          if (error instanceof CodexError2) {
-            throw error;
-          }
-          throw new CodexError2(
-            `Failed to initialize CodexClient: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      /**
-       * Fetch a document by codex:// URI
-       *
-       * This method:
-       * 1. Validates the URI format
-       * 2. Resolves the URI to a reference
-       * 3. Uses CacheManager.get() which handles cache-first fetch
-       *
-       * @param uri - Codex URI (e.g., codex://org/project/path/to/file.md)
-       * @param options - Fetch options
-       * @returns Promise resolving to fetch result
-       *
-       * @throws {CodexError} If URI format is invalid or fetch fails
-       *
-       * @example
-       * ```typescript
-       * const result = await client.fetch('codex://fractary/codex/docs/README.md');
-       * console.log(result.content.toString());
-       * ```
-       */
-      async fetch(uri, options) {
-        const { validateUri, resolveReference, CodexError: CodexError2 } = await import('@fractary/codex');
-        if (!validateUri(uri)) {
-          throw new CodexError2(`Invalid codex URI: ${uri}`);
-        }
-        const resolved = resolveReference(uri);
-        if (!resolved) {
-          throw new CodexError2(`Failed to resolve URI: ${uri}`);
-        }
-        try {
-          if (options?.bypassCache) {
-            const result2 = await this.storage.fetch(resolved);
-            return {
-              content: result2.content,
-              fromCache: false,
-              metadata: {
-                fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                contentLength: result2.size
-              }
-            };
-          }
-          const result = await this.cache.get(resolved, {
-            ttl: options?.ttl
-          });
-          return {
-            content: result.content,
-            fromCache: true,
-            // CacheManager.get handles cache logic
-            metadata: {
-              contentLength: result.size
-            }
-          };
-        } catch (error) {
-          throw new CodexError2(
-            `Failed to fetch ${uri}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      /**
-       * Invalidate cache entries
-       *
-       * @param pattern - Optional glob pattern to match entries
-       *                  If not provided, clears all entries
-       *
-       * @example
-       * ```typescript
-       * // Clear all cache
-       * await client.invalidateCache();
-       *
-       * // Clear specific URI
-       * await client.invalidateCache('codex://fractary/codex/docs/README.md');
-       * ```
-       */
-      async invalidateCache(pattern) {
-        if (pattern) {
-          await this.cache.invalidate(pattern);
-        } else {
-          await this.cache.clear();
-        }
-      }
-      /**
-       * Get cache statistics
-       *
-       * @returns Promise resolving to cache stats
-       *
-       * @example
-       * ```typescript
-       * const stats = await client.getCacheStats();
-       * console.log(`Cache entries: ${stats.totalEntries}`);
-       * console.log(`Total size: ${stats.totalSize}`);
-       * ```
-       */
-      async getCacheStats() {
-        return this.cache.getStats();
-      }
-      /**
-       * Get the type registry
-       *
-       * Provides access to built-in and custom artifact types
-       *
-       * @returns TypeRegistry instance
-       *
-       * @example
-       * ```typescript
-       * const registry = client.getTypeRegistry();
-       * const types = registry.list();
-       * ```
-       */
-      getTypeRegistry() {
-        return this.types;
-      }
-      /**
-       * Get the cache manager (for advanced operations)
-       *
-       * @returns CacheManager instance
-       */
-      getCacheManager() {
-        return this.cache;
-      }
-      /**
-       * Get the storage manager (for advanced operations)
-       *
-       * @returns StorageManager instance
-       */
-      getStorageManager() {
-        return this.storage;
-      }
-      /**
-       * Get the organization slug
-       *
-       * @returns Organization slug string
-       */
-      getOrganization() {
-        return this.organization;
-      }
-    };
   }
 });
 
@@ -600,7 +135,7 @@ function getTempCodexPath(config) {
   const codexRepo = config.codex_repo || "codex";
   const sanitizedOrg = sanitizePathComponent(config.organization);
   const sanitizedRepo = sanitizePathComponent(codexRepo);
-  return path4__namespace.join(
+  return path3__namespace.join(
     os__namespace.tmpdir(),
     "fractary-codex-clone",
     `${sanitizedOrg}-${sanitizedRepo}-${process.pid}`
@@ -608,8 +143,8 @@ function getTempCodexPath(config) {
 }
 async function isValidGitRepo(repoPath) {
   try {
-    const gitDir = path4__namespace.join(repoPath, ".git");
-    const stats = await fs__namespace.stat(gitDir);
+    const gitDir = path3__namespace.join(repoPath, ".git");
+    const stats = await fs2__namespace.stat(gitDir);
     return stats.isDirectory();
   } catch {
     return false;
@@ -641,8 +176,8 @@ async function execGit(repoPath, args) {
   }
 }
 async function gitClone(url, targetPath, options) {
-  const parentDir = path4__namespace.dirname(targetPath);
-  await fs__namespace.mkdir(parentDir, { recursive: true });
+  const parentDir = path3__namespace.dirname(targetPath);
+  await fs2__namespace.mkdir(parentDir, { recursive: true });
   const args = ["clone"];
   if (options?.depth) {
     if (!Number.isInteger(options.depth) || options.depth <= 0) {
@@ -689,12 +224,12 @@ async function ensureCodexCloned(config, options) {
     } catch (error) {
       console.warn(`Failed to update existing clone: ${error.message}`);
       console.warn(`Removing and cloning fresh...`);
-      await fs__namespace.rm(tempPath, { recursive: true, force: true });
+      await fs2__namespace.rm(tempPath, { recursive: true, force: true });
     }
   }
   const repoUrl = getCodexRepoUrl(config);
   try {
-    await fs__namespace.rm(tempPath, { recursive: true, force: true });
+    await fs2__namespace.rm(tempPath, { recursive: true, force: true });
   } catch (error) {
     console.warn(`Could not remove existing directory ${tempPath}: ${error.message}`);
   }
@@ -714,85 +249,162 @@ var init_codex_repository = __esm({
 // src/cli.ts
 init_cjs_shims();
 
-// src/commands/document/index.ts
-init_cjs_shims();
-
-// src/commands/document/fetch.ts
+// src/commands/config/index.ts
 init_cjs_shims();
 
-// src/client/get-client.ts
+// src/commands/config/initialize.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) => {
+function configInitializeCommand() {
+  const cmd = new commander.Command("config-initialize");
+  cmd.description("Initialize codex section in .fractary/config.yaml (requires base config from @fractary/core)").option("--org <slug>", 'Organization slug (e.g., "fractary")').option("--project <name>", "Project name (default: derived from directory)").option("--codex-repo <name>", 'Codex repository name (e.g., "codex.fractary.com")').option("--sync-preset <name>", "Sync preset (standard, minimal)", "standard").option("--force", "Overwrite existing codex section").option("--no-mcp", "Skip MCP server installation").option("--json", "Output as JSON").action(async (options) => {
     try {
-      const { validateUri } = await import('@fractary/codex');
-      if (!validateUri(uri)) {
-        console.error(chalk7__default.default.red("Error: Invalid URI format"));
-        console.log(chalk7__default.default.dim("Expected: codex://org/project/path/to/file.md"));
-        console.log(chalk7__default.default.dim("Example: codex://fractary/codex/docs/api.md"));
+      const configManager = codex.createConfigManager(process.cwd());
+      if (!options.json) {
+        console.log(chalk10__default.default.blue("Initializing codex configuration...\n"));
+      }
+      let org = options.org;
+      if (!org) {
+        org = await configManager.detectOrganization();
+      }
+      if (!org) {
+        try {
+          org = codex.resolveOrganization({
+            repoName: path3__namespace.basename(process.cwd())
+          });
+        } catch {
+        }
+      }
+      if (!org) {
+        org = path3__namespace.basename(process.cwd()).split("-")[0] || "default";
+        if (!options.json) {
+          console.log(chalk10__default.default.yellow(`\u26A0 Could not detect organization, using: ${org}`));
+          console.log(chalk10__default.default.dim("  Use --org <slug> to specify explicitly\n"));
+        }
+      } else if (!options.json) {
+        console.log(chalk10__default.default.dim(`Organization: ${chalk10__default.default.cyan(org)}
+`));
+      }
+      const orgValidation = codex.validateNameFormat(org, "organization");
+      if (!orgValidation.valid) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: orgValidation.error }, null, 2));
+        } else {
+          console.error(chalk10__default.default.red("Error:"), orgValidation.error);
+        }
         process.exit(1);
       }
-      const client = await getClient();
-      if (!options.json && !options.bypassCache) {
-        console.error(chalk7__default.default.dim(`Fetching ${uri}...`));
+      let project = options.project;
+      if (!project) {
+        project = configManager.detectProject();
+        if (!options.json) {
+          console.log(chalk10__default.default.dim(`Project: ${chalk10__default.default.cyan(project)}
+`));
+        }
       }
-      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)
+      let codexRepo = options.codexRepo;
+      if (codexRepo) {
+        const repoValidation = codex.validateNameFormat(codexRepo, "repository");
+        if (!repoValidation.valid) {
+          if (options.json) {
+            console.log(JSON.stringify({ error: repoValidation.error }, null, 2));
+          } else {
+            console.error(chalk10__default.default.red("Error:"), repoValidation.error);
           }
-        };
-        console.log(JSON.stringify(output, null, 2));
-      } else if (options.output) {
-        await fs__namespace.writeFile(options.output, result.content);
-        console.log(chalk7__default.default.green("\u2713"), `Written to ${options.output}`);
-        console.log(chalk7__default.default.dim(`  Size: ${result.content.length} bytes`));
-        if (result.fromCache) {
-          console.log(chalk7__default.default.dim("  Source: cache"));
-        } else {
-          console.log(chalk7__default.default.dim("  Source: storage"));
+          process.exit(1);
+        }
+        if (!options.json) {
+          console.log(chalk10__default.default.dim(`Codex repository: ${chalk10__default.default.cyan(codexRepo)}
+`));
         }
       } else {
-        if (result.fromCache && !options.bypassCache) {
-          console.error(chalk7__default.default.green("\u2713"), chalk7__default.default.dim("from cache\n"));
-        } else {
-          console.error(chalk7__default.default.green("\u2713"), chalk7__default.default.dim("fetched\n"));
+        const discoveryResult = await configManager.discoverCodexRepo(org);
+        if (discoveryResult.repo) {
+          codexRepo = discoveryResult.repo;
+          if (!options.json) {
+            console.log(chalk10__default.default.dim(`Codex repository: ${chalk10__default.default.cyan(codexRepo)} (auto-discovered)
+`));
+          }
+        } else if (!options.json) {
+          if (discoveryResult.message) {
+            console.log(chalk10__default.default.dim(`  Note: ${discoveryResult.message}
+`));
+          }
         }
-        console.log(result.content.toString("utf-8"));
       }
+      if (!codexRepo) {
+        codexRepo = `codex.${org}.com`;
+        if (!options.json) {
+          console.log(chalk10__default.default.yellow(`\u26A0 Could not discover codex repository in organization '${org}'`));
+          console.log(chalk10__default.default.dim(`  Using default: ${chalk10__default.default.cyan(codexRepo)}
+`));
+        }
+      }
+      const result = await configManager.initializeCodexSection({
+        organization: org,
+        project,
+        codexRepo,
+        syncPreset: options.syncPreset,
+        force: options.force,
+        skipMcp: options.mcp === false
+      });
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              configPath: result.configPath,
+              codexSectionCreated: result.codexSectionCreated,
+              organization: org,
+              project,
+              codexRepo,
+              directories: result.directories,
+              gitignore: result.gitignore,
+              mcp: result.mcp
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log("Setting up codex directories...");
+      for (const dir of result.directories.created) {
+        console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(dir + "/"));
+      }
+      for (const dir of result.directories.alreadyExisted) {
+        console.log(chalk10__default.default.dim("  " + dir + "/ (exists)"));
+      }
+      if (result.gitignore.created) {
+        console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".fractary/.gitignore (created)"));
+      } else if (result.gitignore.updated) {
+        console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".fractary/.gitignore (updated)"));
+      } else {
+        console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".fractary/.gitignore (exists)"));
+      }
+      console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".fractary/config.yaml (codex section added)"));
+      if (result.mcp) {
+        if (result.mcp.alreadyInstalled) {
+          console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".mcp.json (already configured)"));
+        } else if (result.mcp.migrated) {
+          console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".mcp.json (migrated from old format)"));
+        } else if (result.mcp.installed) {
+          console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".mcp.json (created)"));
+        }
+      }
+      console.log(chalk10__default.default.green("\n\u2713 Codex configuration initialized successfully!\n"));
+      console.log(chalk10__default.default.bold("Configuration:"));
+      console.log(chalk10__default.default.dim(`  Organization: ${org}`));
+      console.log(chalk10__default.default.dim(`  Project: ${project}`));
+      console.log(chalk10__default.default.dim(`  Codex Repository: ${codexRepo}`));
+      console.log(chalk10__default.default.bold("\nNext steps:"));
+      console.log(chalk10__default.default.dim("  1. Restart Claude Code to load the MCP server"));
+      console.log(chalk10__default.default.dim(`  2. Verify codex repository access: gh repo view ${org}/${codexRepo}`));
+      console.log(chalk10__default.default.dim("  3. Run first sync: /fractary-codex:sync --from-codex --dry-run"));
     } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
-      if (error.message.includes("Failed to load configuration")) {
-        console.log(chalk7__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
-      } else if (error.message.includes("GITHUB_TOKEN")) {
-        console.log(chalk7__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(chalk7__default.default.dim("\nThe document may not exist or you may not have access."));
-        console.log(chalk7__default.default.dim("Check the URI and ensure your storage providers are configured correctly."));
+      if (options.json) {
+        console.log(JSON.stringify({ error: error.message }, null, 2));
+      } else {
+        console.error(chalk10__default.default.red("Error:"), error.message);
       }
       process.exit(1);
     }
@@ -800,612 +412,345 @@ function fetchCommand() {
   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();
-
-// src/config/unified-config.ts
+// src/commands/config/update.ts
 init_cjs_shims();
-function sanitizeForS3BucketName(name) {
-  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").substring(0, 63);
-}
-function getDefaultUnifiedConfig(organization, project, codexRepo) {
-  const sanitizedProject = sanitizeForS3BucketName(project);
-  return {
-    file: {
-      schema_version: codex.CONFIG_SCHEMA_VERSION,
-      sources: {
-        specs: {
-          type: "s3",
-          bucket: `${sanitizedProject}-files`,
-          prefix: "specs/",
-          region: "us-east-1",
-          local: {
-            base_path: ".fractary/specs"
-          },
-          push: {
-            compress: false,
-            keep_local: true
-          },
-          auth: {
-            profile: "default"
-          }
-        },
-        logs: {
-          type: "s3",
-          bucket: `${sanitizedProject}-files`,
-          prefix: "logs/",
-          region: "us-east-1",
-          local: {
-            base_path: ".fractary/logs"
-          },
-          push: {
-            compress: true,
-            keep_local: true
-          },
-          auth: {
-            profile: "default"
-          }
+function configUpdateCommand() {
+  const cmd = new commander.Command("config-update");
+  cmd.description("Update codex configuration fields in .fractary/config.yaml").option("--org <slug>", "Update organization slug").option("--project <name>", "Update project name").option("--codex-repo <name>", "Update codex repository name").option("--sync-preset <name>", "Update sync preset (standard, minimal)").option("--no-mcp", "Skip MCP server update").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const configManager = codex.createConfigManager(process.cwd());
+      const updateOptions = {
+        skipMcp: options.mcp === false
+      };
+      let hasUpdates = false;
+      if (options.org !== void 0) {
+        updateOptions.organization = options.org;
+        hasUpdates = true;
+      }
+      if (options.project !== void 0) {
+        updateOptions.project = options.project;
+        hasUpdates = true;
+      }
+      if (options.codexRepo !== void 0) {
+        updateOptions.codexRepo = options.codexRepo;
+        hasUpdates = true;
+      }
+      if (options.syncPreset !== void 0) {
+        updateOptions.syncPreset = options.syncPreset;
+        hasUpdates = true;
+      }
+      if (!hasUpdates) {
+        if (options.json) {
+          console.log(JSON.stringify({ error: "No fields to update. Provide at least one of: --org, --project, --codex-repo, --sync-preset" }, null, 2));
+        } else {
+          console.error(chalk10__default.default.red("Error:"), "No fields to update. Provide at least one of: --org, --project, --codex-repo, --sync-preset");
         }
+        process.exit(1);
+      }
+      if (!options.json) {
+        console.log(chalk10__default.default.blue("Updating codex configuration...\n"));
       }
-    },
-    codex: {
-      schema_version: codex.CONFIG_SCHEMA_VERSION,
-      organization,
-      project,
-      codex_repo: codexRepo,
-      remotes: {
-        // The codex repository - uses same token as git operations
-        [`${organization}/${codexRepo}`]: {
-          token: "${GITHUB_TOKEN}"
+      const result = await configManager.updateCodexSection(updateOptions);
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              configPath: result.configPath,
+              fieldsUpdated: result.fieldsUpdated,
+              mcp: result.mcp
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      if (result.fieldsUpdated.length === 0) {
+        console.log(chalk10__default.default.yellow("No fields were updated."));
+        return;
+      }
+      for (const field of result.fieldsUpdated) {
+        console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(`Updated: ${field}`));
+      }
+      if (result.mcp) {
+        if (result.mcp.alreadyInstalled) {
+          console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".mcp.json (already configured)"));
+        } else if (result.mcp.installed) {
+          console.log(chalk10__default.default.green("\u2713"), chalk10__default.default.dim(".mcp.json (updated)"));
         }
       }
+      console.log(chalk10__default.default.green("\n\u2713 Codex configuration updated successfully!"));
+    } catch (error) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: error.message }, null, 2));
+      } else {
+        console.error(chalk10__default.default.red("Error:"), error.message);
+      }
+      process.exit(1);
     }
-  };
-}
-async function readUnifiedConfig(configPath) {
-  try {
-    const content = await fs__namespace.readFile(configPath, "utf-8");
-    const config = yaml2__namespace.load(content);
-    return config;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-async function writeUnifiedConfig(config, outputPath) {
-  const dir = path4__namespace.dirname(outputPath);
-  await fs__namespace.mkdir(dir, { recursive: true });
-  const yamlContent = yaml2__namespace.dump(config, {
-    indent: 2,
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
   });
-  await fs__namespace.writeFile(outputPath, yamlContent, "utf-8");
-}
-function mergeUnifiedConfigs(existing, updates) {
-  const merged = {};
-  if (updates.file || existing.file) {
-    merged.file = {
-      schema_version: updates.file?.schema_version || existing.file?.schema_version || codex.CONFIG_SCHEMA_VERSION,
-      sources: {
-        ...existing.file?.sources || {},
-        ...updates.file?.sources || {}
-      }
-    };
-  }
-  if (updates.codex || existing.codex) {
-    merged.codex = {
-      schema_version: updates.codex?.schema_version || existing.codex?.schema_version || codex.CONFIG_SCHEMA_VERSION,
-      organization: updates.codex?.organization || existing.codex?.organization || "default",
-      project: updates.codex?.project || existing.codex?.project || "default",
-      codex_repo: updates.codex?.codex_repo || existing.codex?.codex_repo || "",
-      remotes: {
-        ...existing.codex?.remotes || {},
-        ...updates.codex?.remotes || {}
-      }
-    };
-  }
-  return merged;
-}
-async function initializeUnifiedConfig(configPath, organization, project, codexRepo, options) {
-  const existingConfig = await readUnifiedConfig(configPath);
-  if (existingConfig && !options?.force) {
-    const defaultConfig = getDefaultUnifiedConfig(organization, project, codexRepo);
-    const merged = mergeUnifiedConfigs(existingConfig, defaultConfig);
-    await writeUnifiedConfig(merged, configPath);
-    return {
-      created: false,
-      merged: true,
-      config: merged
-    };
-  }
-  const config = getDefaultUnifiedConfig(organization, project, codexRepo);
-  await writeUnifiedConfig(config, configPath);
-  return {
-    created: true,
-    merged: false,
-    config
-  };
+  return cmd;
 }
 
-// src/config/gitignore-utils.ts
+// src/commands/config/validate.ts
 init_cjs_shims();
-var DEFAULT_FRACTARY_GITIGNORE = `# .fractary/.gitignore
-# This file is managed by multiple plugins - each plugin manages its own section
-
-# ===== fractary-codex (managed) =====
-codex/cache/
-# ===== end fractary-codex =====
-`;
-async function readFractaryGitignore(projectRoot) {
-  const gitignorePath = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
-  try {
-    return await fs__namespace.readFile(gitignorePath, "utf-8");
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-async function writeFractaryGitignore(projectRoot, content) {
-  const gitignorePath = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
-  await fs__namespace.mkdir(path4__namespace.join(projectRoot, ".fractary"), { recursive: true });
-  await fs__namespace.writeFile(gitignorePath, content, "utf-8");
-}
-function normalizeCachePath(cachePath) {
-  let normalized = cachePath.replace(/\\/g, "/");
-  normalized = normalized.replace(/^\.fractary\//, "");
-  if (!normalized.endsWith("/")) {
-    normalized += "/";
-  }
-  return normalized;
-}
-function isCachePathIgnored(gitignoreContent, cachePath) {
-  const normalized = normalizeCachePath(cachePath);
-  const lines = gitignoreContent.split("\n").map((l) => l.trim());
-  return lines.some((line) => {
-    if (line.startsWith("#") || line === "") return false;
-    let normalizedLine = line.replace(/\\/g, "/");
-    if (!normalizedLine.endsWith("/")) {
-      normalizedLine += "/";
+function configValidateCommand() {
+  const cmd = new commander.Command("config-validate");
+  cmd.description("Validate codex configuration in .fractary/config.yaml (read-only)").option("--json", "Output as JSON").action(async (options) => {
+    try {
+      const configManager = codex.createConfigManager(process.cwd());
+      if (!options.json) {
+        console.log(chalk10__default.default.blue("Validating codex configuration...\n"));
+      }
+      const result = await configManager.validateCodexConfig();
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.valid) {
+          process.exit(1);
+        }
+        return;
+      }
+      if (result.errors.length > 0) {
+        console.log(chalk10__default.default.red.bold("Errors:"));
+        for (const error of result.errors) {
+          console.log(chalk10__default.default.red("  \u2717"), `${error.field}: ${error.message}`);
+        }
+        console.log();
+      }
+      if (result.warnings.length > 0) {
+        console.log(chalk10__default.default.yellow.bold("Warnings:"));
+        for (const warning of result.warnings) {
+          console.log(chalk10__default.default.yellow("  \u26A0"), `${warning.field}: ${warning.message}`);
+        }
+        console.log();
+      }
+      if (result.valid) {
+        if (result.warnings.length === 0) {
+          console.log(chalk10__default.default.green("\u2713 Codex configuration is valid with no warnings."));
+        } else {
+          console.log(chalk10__default.default.green("\u2713 Codex configuration is valid"), chalk10__default.default.yellow(`(${result.warnings.length} warning${result.warnings.length > 1 ? "s" : ""})`));
+        }
+      } else {
+        console.log(chalk10__default.default.red(`\u2717 Codex configuration is invalid (${result.errors.length} error${result.errors.length > 1 ? "s" : ""})`));
+        process.exit(1);
+      }
+    } catch (error) {
+      if (options.json) {
+        console.log(JSON.stringify({ error: error.message }, null, 2));
+      } else {
+        console.error(chalk10__default.default.red("Error:"), error.message);
+      }
+      process.exit(1);
     }
-    return normalizedLine === normalized;
   });
-}
-function addCachePathToGitignore(gitignoreContent, cachePath, comment) {
-  const normalized = normalizeCachePath(cachePath);
-  if (isCachePathIgnored(gitignoreContent, cachePath)) {
-    return gitignoreContent;
-  }
-  let addition = "";
-  {
-    addition += `
-# ${comment}
-`;
-  }
-  addition += normalized + "\n";
-  return gitignoreContent.trimEnd() + addition;
-}
-async function ensureCachePathIgnored(projectRoot, cachePath) {
-  const gitignorePath = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
-  let relativeCachePath = cachePath;
-  if (path4__namespace.isAbsolute(cachePath)) {
-    relativeCachePath = path4__namespace.relative(path4__namespace.join(projectRoot, ".fractary"), cachePath);
-  }
-  relativeCachePath = normalizeCachePath(relativeCachePath);
-  let content = await readFractaryGitignore(projectRoot);
-  const gitignoreExists = content !== null;
-  if (!gitignoreExists) {
-    content = DEFAULT_FRACTARY_GITIGNORE;
-    if (!isCachePathIgnored(content, relativeCachePath)) {
-      content = addCachePathToGitignore(content, relativeCachePath, "Custom cache directory");
-    }
-    await writeFractaryGitignore(projectRoot, content);
-    return {
-      created: true,
-      updated: false,
-      alreadyIgnored: false,
-      gitignorePath
-    };
-  }
-  if (isCachePathIgnored(content, relativeCachePath)) {
-    return {
-      created: false,
-      updated: false,
-      alreadyIgnored: true,
-      gitignorePath
-    };
-  }
-  content = addCachePathToGitignore(content, relativeCachePath, "Custom cache directory");
-  await writeFractaryGitignore(projectRoot, content);
-  return {
-    created: false,
-    updated: true,
-    alreadyIgnored: false,
-    gitignorePath
-  };
+  return cmd;
 }
 
 // src/commands/config/init.ts
-function validateNameFormat(name, type) {
-  if (!name || typeof name !== "string") {
-    throw new Error(`${type} name is required`);
-  }
-  if (name.length > 100) {
-    throw new Error(`${type} name too long (max 100 characters)`);
-  }
-  const safePattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-  if (!safePattern.test(name)) {
-    throw new Error(
-      `Invalid ${type} name format: "${name}". Must start with alphanumeric and contain only: a-z, A-Z, 0-9, ., -, _`
-    );
-  }
-}
-async function getOrgFromGitRemote() {
-  try {
-    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;
-  } catch {
-    return null;
-  }
-}
-async function discoverCodexRepo(org) {
-  try {
-    validateNameFormat(org, "organization");
-  } catch (error) {
-    return { repo: null, error: "unknown", message: error.message };
-  }
-  try {
-    const { execSync } = __require("child_process");
-    try {
-      execSync("gh --version", { encoding: "utf-8", stdio: "pipe" });
-    } catch {
-      return {
-        repo: null,
-        error: "gh_not_installed",
-        message: "GitHub CLI (gh) is not installed. Install from https://cli.github.com/"
-      };
-    }
-    try {
-      execSync("gh auth status", { encoding: "utf-8", stdio: "pipe" });
-    } catch {
-      return {
-        repo: null,
-        error: "auth_failed",
-        message: "GitHub CLI not authenticated. Run: gh auth login"
-      };
-    }
-    const result = execSync(
-      `gh repo list ${org} --json name --jq '.[].name | select(startswith("codex."))' 2>&1`,
-      { encoding: "utf-8" }
-    ).trim();
-    if (result.includes("Could not resolve to an Organization") || result.includes("Not Found")) {
-      return {
-        repo: null,
-        error: "org_not_found",
-        message: `Organization '${org}' not found on GitHub`
-      };
-    }
-    const repos = result.split("\n").filter(Boolean);
-    if (repos.length === 0) {
-      return {
-        repo: null,
-        error: "no_repos_found",
-        message: `No codex.* repositories found in organization '${org}'`
-      };
-    }
-    return { repo: repos[0] };
-  } catch (error) {
-    return {
-      repo: null,
-      error: "unknown",
-      message: error.message || "Unknown error during discovery"
-    };
-  }
-}
-async function fileExists(filePath) {
-  try {
-    await fs__namespace.access(filePath);
-    return true;
-  } catch {
-    return false;
+init_cjs_shims();
+
+// 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;
 }
-async function installMcpServer(projectRoot, configPath = ".fractary/config.yaml", options = {}) {
-  const mcpJsonPath = path4__namespace.join(projectRoot, ".mcp.json");
-  const { backup = true } = options;
-  let existingConfig = { mcpServers: {} };
-  let backupPath;
-  let migrated = false;
-  if (await fileExists(mcpJsonPath)) {
-    try {
-      const content = await fs__namespace.readFile(mcpJsonPath, "utf-8");
-      existingConfig = JSON.parse(content);
-      if (backup) {
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").slice(0, 18);
-        const suffix = Math.random().toString(36).substring(2, 6);
-        backupPath = `${mcpJsonPath}.backup.${timestamp}-${suffix}`;
-        await fs__namespace.writeFile(backupPath, content);
-      }
-    } catch {
-      console.log(chalk7__default.default.yellow("\u26A0 Warning: .mcp.json contains invalid JSON, starting fresh"));
-      existingConfig = { mcpServers: {} };
-    }
-  }
-  if (!existingConfig.mcpServers) {
-    existingConfig.mcpServers = {};
-  }
-  const existing = existingConfig.mcpServers["fractary-codex"];
-  if (existing) {
-    const existingCommand = existing.command;
-    const existingArgs = existing.args || [];
-    if (existingCommand === "npx" && existingArgs.includes("@fractary/codex-mcp")) {
-      return {
-        installed: false,
-        migrated: false,
-        alreadyInstalled: true,
-        backupPath
-      };
-    }
-    if (existingCommand === "node" || existingArgs.includes("@fractary/codex")) {
-      migrated = true;
-    }
-  }
-  existingConfig.mcpServers["fractary-codex"] = {
-    command: "npx",
-    args: ["-y", "@fractary/codex-mcp", "--config", configPath]
-  };
-  await fs__namespace.writeFile(
-    mcpJsonPath,
-    JSON.stringify(existingConfig, null, 2) + "\n"
-  );
-  return {
-    installed: true,
-    migrated,
-    alreadyInstalled: false,
-    backupPath
-  };
+
+// src/commands/document/fetch.ts
+function hashContent(content) {
+  return crypto__namespace.createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
-function initCommand() {
-  const cmd = new commander.Command("init");
-  cmd.description("Initialize unified Fractary configuration (.fractary/config.yaml)").option("--org <slug>", 'Organization slug (e.g., "fractary")').option("--project <name>", "Project name (default: derived from directory)").option("--codex-repo <name>", 'Codex repository name (e.g., "codex.fractary.com")').option("--force", "Overwrite existing configuration").option("--no-mcp", "Skip MCP server installation").action(async (options) => {
+function documentFetchCommand() {
+  const cmd = new commander.Command("document-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 {
-      console.log(chalk7__default.default.blue("Initializing unified Fractary configuration...\n"));
-      let org = options.org;
-      if (!org) {
-        org = await getOrgFromGitRemote();
-      }
-      if (!org) {
-        try {
-          const { resolveOrganization } = await import('@fractary/codex');
-          org = resolveOrganization({
-            repoName: path4__namespace.basename(process.cwd())
-          });
-        } catch {
-        }
-      }
-      if (!org) {
-        org = path4__namespace.basename(process.cwd()).split("-")[0] || "default";
-        console.log(chalk7__default.default.yellow(`\u26A0 Could not detect organization, using: ${org}`));
-        console.log(chalk7__default.default.dim("  Use --org <slug> to specify explicitly\n"));
-      } else {
-        console.log(chalk7__default.default.dim(`Organization: ${chalk7__default.default.cyan(org)}
-`));
-      }
-      try {
-        validateNameFormat(org, "organization");
-      } catch (error) {
-        console.error(chalk7__default.default.red("Error:"), error.message);
+      const { validateUri } = await import('@fractary/codex');
+      if (!validateUri(uri)) {
+        console.error(chalk10__default.default.red("Error: Invalid URI format"));
+        console.log(chalk10__default.default.dim("Expected: codex://org/project/path/to/file.md"));
+        console.log(chalk10__default.default.dim("Example: codex://fractary/codex/docs/api.md"));
         process.exit(1);
       }
-      let project = options.project;
-      if (!project) {
-        project = path4__namespace.basename(process.cwd());
-        console.log(chalk7__default.default.dim(`Project: ${chalk7__default.default.cyan(project)}
-`));
+      const client = await getClient();
+      if (!options.json && !options.bypassCache) {
+        console.error(chalk10__default.default.dim(`Fetching ${uri}...`));
       }
-      let codexRepo = options.codexRepo;
-      if (codexRepo) {
-        try {
-          validateNameFormat(codexRepo, "repository");
-        } catch (error) {
-          console.error(chalk7__default.default.red("Error:"), error.message);
-          process.exit(1);
-        }
-        console.log(chalk7__default.default.dim(`Codex repository: ${chalk7__default.default.cyan(codexRepo)}
-`));
-      } else {
-        const discoveryResult = await discoverCodexRepo(org);
-        if (discoveryResult.repo) {
-          codexRepo = discoveryResult.repo;
-          console.log(chalk7__default.default.dim(`Codex repository: ${chalk7__default.default.cyan(codexRepo)} (auto-discovered)
-`));
-        } else {
-          if (discoveryResult.error === "gh_not_installed") {
-            console.log(chalk7__default.default.dim(`  Note: ${discoveryResult.message}
-`));
-          } else if (discoveryResult.error === "auth_failed") {
-            console.log(chalk7__default.default.dim(`  Note: ${discoveryResult.message}
-`));
-          } else if (discoveryResult.error === "org_not_found") {
-            console.log(chalk7__default.default.dim(`  Note: ${discoveryResult.message}
-`));
+      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 fs2__namespace.writeFile(options.output, result.content);
+        console.log(chalk10__default.default.green("\u2713"), `Written to ${options.output}`);
+        console.log(chalk10__default.default.dim(`  Size: ${result.content.length} bytes`));
+        if (result.fromCache) {
+          console.log(chalk10__default.default.dim("  Source: cache"));
+        } else {
+          console.log(chalk10__default.default.dim("  Source: storage"));
         }
-      }
-      if (!codexRepo) {
-        console.log(chalk7__default.default.yellow(`\u26A0 Could not discover codex repository in organization '${org}'`));
-        console.log(chalk7__default.default.dim("  Use --codex-repo <name> to specify explicitly"));
-        console.log(chalk7__default.default.dim("  Expected naming convention: codex.{org}.{tld} (e.g., codex.fractary.com)\n"));
-        codexRepo = `codex.${org}.com`;
-        console.log(chalk7__default.default.dim(`  Using default: ${chalk7__default.default.cyan(codexRepo)}
-`));
-      }
-      const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
-      const configExists = await fileExists(configPath);
-      if (configExists && !options.force) {
-        console.log(chalk7__default.default.yellow(`\u26A0 Configuration already exists at .fractary/config.yaml`));
-        console.log(chalk7__default.default.dim("Merging with existing configuration...\n"));
-      }
-      console.log("Creating directory structure...");
-      const dirs = [
-        ".fractary",
-        ".fractary/specs",
-        ".fractary/logs",
-        ".fractary/codex",
-        ".fractary/codex/cache"
-      ];
-      for (const dir of dirs) {
-        await fs__namespace.mkdir(path4__namespace.join(process.cwd(), dir), { recursive: true });
-        console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(dir + "/"));
-      }
-      const gitignoreResult = await ensureCachePathIgnored(process.cwd(), ".fractary/codex/cache");
-      if (gitignoreResult.created) {
-        console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".fractary/.gitignore (created)"));
-      } else if (gitignoreResult.updated) {
-        console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".fractary/.gitignore (updated)"));
       } else {
-        console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".fractary/.gitignore (exists)"));
-      }
-      console.log("\nInitializing configuration...");
-      const result = await initializeUnifiedConfig(
-        configPath,
-        org,
-        project,
-        codexRepo,
-        { force: options.force }
-      );
-      if (result.created) {
-        console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".fractary/config.yaml (created)"));
-      } else if (result.merged) {
-        console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".fractary/config.yaml (merged with existing)"));
-      }
-      if (options.mcp !== false) {
-        console.log("\nConfiguring MCP server...");
-        const mcpResult = await installMcpServer(process.cwd(), ".fractary/config.yaml");
-        if (mcpResult.alreadyInstalled) {
-          console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".mcp.json (already configured)"));
-        } else if (mcpResult.migrated) {
-          console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".mcp.json (migrated from old format)"));
-          if (mcpResult.backupPath) {
-            console.log(chalk7__default.default.dim(`  Backup: ${path4__namespace.basename(mcpResult.backupPath)}`));
-          }
-        } else if (mcpResult.installed) {
-          console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".mcp.json (created)"));
+        if (result.fromCache && !options.bypassCache) {
+          console.error(chalk10__default.default.green("\u2713"), chalk10__default.default.dim("from cache\n"));
+        } else {
+          console.error(chalk10__default.default.green("\u2713"), chalk10__default.default.dim("fetched\n"));
         }
+        console.log(result.content.toString("utf-8"));
       }
-      console.log(chalk7__default.default.green("\n\u2713 Unified configuration initialized successfully!\n"));
-      console.log(chalk7__default.default.bold("Configuration:"));
-      console.log(chalk7__default.default.dim(`  Organization: ${org}`));
-      console.log(chalk7__default.default.dim(`  Project: ${project}`));
-      console.log(chalk7__default.default.dim(`  Codex Repository: ${codexRepo}`));
-      console.log(chalk7__default.default.dim(`  Config: .fractary/config.yaml`));
-      console.log(chalk7__default.default.bold("\nFile plugin sources:"));
-      console.log(chalk7__default.default.dim("  - specs: .fractary/specs/ \u2192 S3"));
-      console.log(chalk7__default.default.dim("  - logs: .fractary/logs/ \u2192 S3"));
-      console.log(chalk7__default.default.bold("\nCodex plugin:"));
-      console.log(chalk7__default.default.dim("  - Cache: .fractary/codex/cache/"));
-      console.log(chalk7__default.default.dim("  - MCP Server: @fractary/codex-mcp (via npx)"));
-      console.log(chalk7__default.default.dim("  - Remotes: codex repo configured"));
-      console.log(chalk7__default.default.bold("\nGit Authentication:"));
-      console.log(chalk7__default.default.dim("  Codex sync uses your existing git credentials."));
-      console.log(chalk7__default.default.dim("  Ensure you have access to the codex repository:"));
-      console.log(chalk7__default.default.dim(`    gh repo view ${org}/${codexRepo}`));
-      console.log(chalk7__default.default.dim("  Or set GITHUB_TOKEN environment variable."));
-      console.log(chalk7__default.default.bold("\nNext steps:"));
-      console.log(chalk7__default.default.dim("  1. Restart Claude Code to load the MCP server"));
-      console.log(chalk7__default.default.dim("  2. Verify codex repository access: gh repo view " + org + "/" + codexRepo));
-      console.log(chalk7__default.default.dim("  3. Configure AWS credentials for S3 access (if using file plugin)"));
-      console.log(chalk7__default.default.dim("  4. Edit .fractary/config.yaml to add external project remotes"));
-      console.log(chalk7__default.default.dim("  5. Reference docs via codex:// URIs (auto-fetched by MCP)"));
     } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
+      console.error(chalk10__default.default.red("Error:"), error.message);
+      if (error.message.includes("Failed to load configuration")) {
+        console.log(chalk10__default.default.dim('\nRun "fractary-codex configure" to create a configuration.'));
+      } else if (error.message.includes("GITHUB_TOKEN")) {
+        console.log(chalk10__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(chalk10__default.default.dim("\nThe document may not exist or you may not have access."));
+        console.log(chalk10__default.default.dim("Check the URI and ensure your storage providers are configured correctly."));
+      }
       process.exit(1);
     }
   });
   return cmd;
 }
 
-// src/commands/config/index.ts
-function configCommand() {
-  const cmd = new commander.Command("config");
-  cmd.description("Manage configuration");
-  cmd.addCommand(initCommand());
-  return cmd;
-}
-
 // src/commands/cache/index.ts
 init_cjs_shims();
 
 // src/commands/cache/list.ts
 init_cjs_shims();
-function formatSize(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 formatTtl(seconds) {
+  if (seconds < 0) {
+    const expired = -seconds;
+    if (expired < 60) return chalk10__default.default.red(`expired ${expired}s ago`);
+    if (expired < 3600) return chalk10__default.default.red(`expired ${Math.floor(expired / 60)}m ago`);
+    return chalk10__default.default.red(`expired ${Math.floor(expired / 3600)}h ago`);
+  }
+  if (seconds < 60) return chalk10__default.default.green(`${seconds}s`);
+  if (seconds < 3600) return chalk10__default.default.green(`${Math.floor(seconds / 60)}m`);
+  if (seconds < 86400) return chalk10__default.default.yellow(`${Math.floor(seconds / 3600)}h`);
+  return chalk10__default.default.dim(`${Math.floor(seconds / 86400)}d`);
+}
+function formatStatus(status) {
+  switch (status) {
+    case "fresh":
+      return chalk10__default.default.green("fresh");
+    case "stale":
+      return chalk10__default.default.yellow("stale");
+    case "expired":
+      return chalk10__default.default.red("expired");
+  }
 }
 function cacheListCommand() {
-  const cmd = new commander.Command("list");
-  cmd.description("List cache information").option("--json", "Output as JSON").action(async (options) => {
+  const cmd = new commander.Command("cache-list");
+  cmd.description("List cache entries").option("--json", "Output as JSON").option("--status <status>", "Filter by status (fresh, stale, expired, all)", "all").option("--limit <n>", "Maximum number of entries to show", parseInt).option("--sort <field>", "Sort by field (uri, size, createdAt, expiresAt)", "uri").option("--desc", "Sort in descending order").option("--verbose", "Show detailed entry information").action(async (options) => {
     try {
       const client = await getClient();
-      const stats = await client.getCacheStats();
-      if (stats.entryCount === 0) {
+      const listOptions = {
+        status: options.status,
+        limit: options.limit,
+        sortBy: options.sort,
+        sortDirection: options.desc ? "desc" : "asc"
+      };
+      const result = await client.listCacheEntries(listOptions);
+      if (result.total === 0) {
         if (options.json) {
-          console.log(JSON.stringify({ entries: 0, message: "Cache is empty" }));
+          console.log(JSON.stringify({ entries: [], total: 0, message: "Cache is empty" }));
         } else {
-          console.log(chalk7__default.default.yellow("Cache is empty."));
-          console.log(chalk7__default.default.dim("Fetch some documents to populate the cache."));
+          console.log(chalk10__default.default.yellow("Cache is empty."));
+          console.log(chalk10__default.default.dim("Fetch some documents to populate the cache."));
         }
         return;
       }
       if (options.json) {
-        console.log(JSON.stringify({
-          entryCount: stats.entryCount,
-          totalSize: stats.totalSize,
-          freshCount: stats.freshCount,
-          staleCount: stats.staleCount,
-          expiredCount: stats.expiredCount
-        }, null, 2));
+        console.log(JSON.stringify(result, null, 2));
         return;
       }
-      console.log(chalk7__default.default.bold("Cache Overview\n"));
-      console.log(chalk7__default.default.bold("Entries:"));
-      console.log(`  Total:    ${chalk7__default.default.cyan(stats.entryCount.toString())} entries`);
-      console.log(`  Fresh:    ${chalk7__default.default.green(stats.freshCount.toString())} entries`);
-      console.log(`  Stale:    ${stats.staleCount > 0 ? chalk7__default.default.yellow(stats.staleCount.toString()) : chalk7__default.default.dim("0")} entries`);
-      console.log(`  Expired:  ${stats.expiredCount > 0 ? chalk7__default.default.red(stats.expiredCount.toString()) : chalk7__default.default.dim("0")} entries`);
-      console.log("");
-      console.log(chalk7__default.default.bold("Storage:"));
-      console.log(`  Total size: ${chalk7__default.default.cyan(formatSize(stats.totalSize))}`);
-      console.log("");
-      const healthPercent = stats.entryCount > 0 ? stats.freshCount / stats.entryCount * 100 : 100;
-      const healthColor = healthPercent > 80 ? chalk7__default.default.green : healthPercent > 50 ? chalk7__default.default.yellow : chalk7__default.default.red;
-      console.log(`Cache health: ${healthColor(`${healthPercent.toFixed(0)}% fresh`)}`);
+      console.log(chalk10__default.default.bold(`Cache Entries (${result.entries.length} of ${result.total})
+`));
+      if (options.verbose) {
+        for (const entry of result.entries) {
+          console.log(chalk10__default.default.cyan(entry.uri));
+          console.log(`  Status:       ${formatStatus(entry.status)}`);
+          console.log(`  Size:         ${codex.formatBytes(entry.size)}`);
+          console.log(`  Content-Type: ${chalk10__default.default.dim(entry.contentType)}`);
+          console.log(`  TTL:          ${formatTtl(entry.remainingTtl)}`);
+          console.log(`  In Memory:    ${entry.inMemory ? chalk10__default.default.green("yes") : chalk10__default.default.dim("no")}`);
+          console.log("");
+        }
+      } else {
+        const maxUriLen = Math.min(
+          60,
+          Math.max(...result.entries.map((e) => e.uri.length))
+        );
+        console.log(
+          chalk10__default.default.dim(
+            `${"URI".padEnd(maxUriLen)}  ${"STATUS".padEnd(8)}  ${"SIZE".padEnd(10)}  TTL`
+          )
+        );
+        console.log(chalk10__default.default.dim("\u2500".repeat(maxUriLen + 35)));
+        for (const entry of result.entries) {
+          const uri = entry.uri.length > maxUriLen ? "..." + entry.uri.slice(-(maxUriLen - 3)) : entry.uri.padEnd(maxUriLen);
+          console.log(
+            `${chalk10__default.default.cyan(uri)}  ${formatStatus(entry.status).padEnd(17)}  ${codex.formatBytes(entry.size).padEnd(10)}  ${formatTtl(entry.remainingTtl)}`
+          );
+        }
+      }
+      if (result.hasMore) {
+        console.log("");
+        console.log(
+          chalk10__default.default.dim(
+            `Showing ${result.entries.length} of ${result.total} entries. Use --limit to see more.`
+          )
+        );
+      }
+      const stats = await client.getCacheStats();
       console.log("");
-      console.log(chalk7__default.default.dim("Note: Individual cache entries are managed by the SDK."));
-      console.log(chalk7__default.default.dim('Use "fractary codex cache stats" for detailed statistics.'));
-      console.log(chalk7__default.default.dim('Use "fractary codex cache clear" to clear cache entries.'));
+      console.log(chalk10__default.default.dim("\u2500".repeat(60)));
+      console.log(
+        chalk10__default.default.dim(
+          `Total: ${stats.entryCount} entries (${codex.formatBytes(stats.totalSize)}) | ${stats.freshCount} fresh, ${stats.staleCount} stale, ${stats.expiredCount} expired`
+        )
+      );
     } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
+      const errorMessage = error.message || "Unknown error";
+      if (errorMessage.includes("ENOENT") || errorMessage.includes("not found")) {
+        console.error(chalk10__default.default.red("Error:"), "Cache directory not accessible");
+        console.error(chalk10__default.default.dim('Run "fractary-codex configure" to initialize the cache.'));
+      } else if (errorMessage.includes("EACCES") || errorMessage.includes("permission")) {
+        console.error(chalk10__default.default.red("Error:"), "Permission denied accessing cache directory");
+        console.error(chalk10__default.default.dim("Check file permissions for .fractary/codex/cache/"));
+      } else if (errorMessage.includes("ENOSPC")) {
+        console.error(chalk10__default.default.red("Error:"), "No space left on device");
+        console.error(chalk10__default.default.dim("Free up disk space and try again."));
+      } else if (errorMessage.includes("parse") || errorMessage.includes("JSON")) {
+        console.error(chalk10__default.default.red("Error:"), "Failed to parse cache metadata");
+        console.error(chalk10__default.default.dim('The cache may be corrupted. Try "fractary-codex cache-clear".'));
+      } else {
+        console.error(chalk10__default.default.red("Error:"), errorMessage);
+      }
       process.exit(1);
     }
   });
@@ -1415,13 +760,13 @@ function cacheListCommand() {
 // src/commands/cache/clear.ts
 init_cjs_shims();
 function cacheClearCommand() {
-  const cmd = new commander.Command("clear");
+  const cmd = new commander.Command("cache-clear");
   cmd.description("Clear cache entries").option("--all", "Clear entire cache").option("--pattern <glob>", 'Clear entries matching URI pattern (e.g., "codex://fractary/*")').option("--dry-run", "Show what would be cleared without actually clearing").action(async (options) => {
     try {
       const client = await getClient();
       const statsBefore = await client.getCacheStats();
       if (statsBefore.entryCount === 0) {
-        console.log(chalk7__default.default.yellow("Cache is already empty. Nothing to clear."));
+        console.log(chalk10__default.default.yellow("Cache is already empty. Nothing to clear."));
         return;
       }
       let pattern;
@@ -1430,65 +775,55 @@ function cacheClearCommand() {
       } else if (options.pattern) {
         pattern = options.pattern;
       } else {
-        console.log(chalk7__default.default.yellow("Please specify what to clear:"));
-        console.log(chalk7__default.default.dim("  --all        Clear entire cache"));
-        console.log(chalk7__default.default.dim('  --pattern    Clear entries matching pattern (e.g., "codex://fractary/*")'));
+        console.log(chalk10__default.default.yellow("Please specify what to clear:"));
+        console.log(chalk10__default.default.dim("  --all        Clear entire cache"));
+        console.log(chalk10__default.default.dim('  --pattern    Clear entries matching pattern (e.g., "codex://fractary/*")'));
         console.log("");
-        console.log(chalk7__default.default.dim("Examples:"));
-        console.log(chalk7__default.default.dim("  fractary codex cache clear --all"));
-        console.log(chalk7__default.default.dim('  fractary codex cache clear --pattern "codex://fractary/cli/*"'));
+        console.log(chalk10__default.default.dim("Examples:"));
+        console.log(chalk10__default.default.dim("  fractary-codex cache-clear --all"));
+        console.log(chalk10__default.default.dim('  fractary-codex cache-clear --pattern "codex://fractary/cli/*"'));
         return;
       }
       if (options.dryRun) {
-        console.log(chalk7__default.default.blue("Dry run - would clear:\n"));
+        console.log(chalk10__default.default.blue("Dry run - would clear:\n"));
         if (pattern) {
-          console.log(chalk7__default.default.dim(`  Pattern: ${pattern}`));
-          console.log(chalk7__default.default.dim(`  This would invalidate matching cache entries`));
+          console.log(chalk10__default.default.dim(`  Pattern: ${pattern}`));
+          console.log(chalk10__default.default.dim(`  This would invalidate matching cache entries`));
         } else {
-          console.log(chalk7__default.default.dim(`  All cache entries (${statsBefore.entryCount} entries)`));
+          console.log(chalk10__default.default.dim(`  All cache entries (${statsBefore.entryCount} entries)`));
         }
-        console.log(chalk7__default.default.dim(`
-Total size: ${formatSize2(statsBefore.totalSize)}`));
+        console.log(chalk10__default.default.dim(`
+Total size: ${codex.formatBytes(statsBefore.totalSize)}`));
         return;
       }
       if (pattern) {
-        console.log(chalk7__default.default.blue(`Clearing cache entries matching pattern: ${pattern}
+        console.log(chalk10__default.default.blue(`Clearing cache entries matching pattern: ${pattern}
 `));
         await client.invalidateCache(pattern);
       } else {
-        console.log(chalk7__default.default.blue(`Clearing entire cache (${statsBefore.entryCount} entries)...
+        console.log(chalk10__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(chalk7__default.default.green(`\u2713 Cleared ${entriesCleared} entries (${formatSize2(sizeFreed)} freed)`));
+      console.log(chalk10__default.default.green(`\u2713 Cleared ${entriesCleared} entries (${codex.formatBytes(sizeFreed)} freed)`));
       if (statsAfter.entryCount > 0) {
-        console.log(chalk7__default.default.dim(`  Remaining: ${statsAfter.entryCount} entries (${formatSize2(statsAfter.totalSize)})`));
+        console.log(chalk10__default.default.dim(`  Remaining: ${statsAfter.entryCount} entries (${codex.formatBytes(statsAfter.totalSize)})`));
       }
     } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
+      console.error(chalk10__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
   return cmd;
 }
-function formatSize2(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
 
 // src/commands/cache/stats.ts
 init_cjs_shims();
-function formatSize3(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 cacheStatsCommand() {
-  const cmd = new commander.Command("stats");
+  const cmd = new commander.Command("cache-stats");
   cmd.description("Display cache statistics").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient();
@@ -1497,25 +832,25 @@ function cacheStatsCommand() {
         console.log(JSON.stringify(stats, null, 2));
         return;
       }
-      console.log(chalk7__default.default.bold("Cache Statistics\n"));
-      console.log(chalk7__default.default.bold("Overview"));
-      console.log(`  Total entries:     ${chalk7__default.default.cyan(stats.entryCount.toString())}`);
-      console.log(`  Total size:        ${chalk7__default.default.cyan(formatSize3(stats.totalSize))}`);
-      console.log(`  Fresh entries:     ${chalk7__default.default.green(stats.freshCount.toString())}`);
-      console.log(`  Stale entries:     ${stats.staleCount > 0 ? chalk7__default.default.yellow(stats.staleCount.toString()) : chalk7__default.default.dim("0")}`);
-      console.log(`  Expired entries:   ${stats.expiredCount > 0 ? chalk7__default.default.red(stats.expiredCount.toString()) : chalk7__default.default.dim("0")}`);
+      console.log(chalk10__default.default.bold("Cache Statistics\n"));
+      console.log(chalk10__default.default.bold("Overview"));
+      console.log(`  Total entries:     ${chalk10__default.default.cyan(stats.entryCount.toString())}`);
+      console.log(`  Total size:        ${chalk10__default.default.cyan(codex.formatBytes(stats.totalSize))}`);
+      console.log(`  Fresh entries:     ${chalk10__default.default.green(stats.freshCount.toString())}`);
+      console.log(`  Stale entries:     ${stats.staleCount > 0 ? chalk10__default.default.yellow(stats.staleCount.toString()) : chalk10__default.default.dim("0")}`);
+      console.log(`  Expired entries:   ${stats.expiredCount > 0 ? chalk10__default.default.red(stats.expiredCount.toString()) : chalk10__default.default.dim("0")}`);
       console.log("");
       const healthPercent = stats.entryCount > 0 ? stats.freshCount / stats.entryCount * 100 : 100;
-      const healthColor = healthPercent > 80 ? chalk7__default.default.green : healthPercent > 50 ? chalk7__default.default.yellow : chalk7__default.default.red;
+      const healthColor = healthPercent > 80 ? chalk10__default.default.green : healthPercent > 50 ? chalk10__default.default.yellow : chalk10__default.default.red;
       console.log(`Cache health: ${healthColor(`${healthPercent.toFixed(0)}% fresh`)}`);
       if (stats.expiredCount > 0) {
-        console.log(chalk7__default.default.dim('\nRun "fractary codex cache clear --pattern <pattern>" to clean up entries.'));
+        console.log(chalk10__default.default.dim('\nRun "fractary-codex cache-clear --pattern <pattern>" to clean up entries.'));
       }
       if (stats.entryCount === 0) {
-        console.log(chalk7__default.default.dim("\nNo cached entries. Fetch some documents to populate the cache."));
+        console.log(chalk10__default.default.dim("\nNo cached entries. Fetch some documents to populate the cache."));
       }
     } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
+      console.error(chalk10__default.default.red("Error:"), error.message);
       process.exit(1);
     }
   });
@@ -1524,260 +859,94 @@ function cacheStatsCommand() {
 
 // src/commands/cache/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 = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
-  const legacyConfigPath = path4__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 codex.readCodexConfig(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 = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
-  try {
-    const config = await codex.readCodexConfig(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/config.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");
+function cacheHealthCommand() {
+  const cmd = new commander.Command("cache-health");
   cmd.description("Run diagnostics on codex setup").option("--json", "Output as JSON").action(async (options) => {
     try {
+      const healthChecker = codex.createHealthChecker({
+        projectRoot: process.cwd()
+      });
       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;
+      checks.push(await healthChecker.checkConfiguration());
+      checks.push(await healthChecker.checkStorage());
+      try {
+        const client = await getClient();
+        const organization = client.getOrganization();
+        checks.push({
+          name: "SDK Client",
+          status: "pass",
+          message: "CodexClient initialized successfully",
+          details: `Organization: ${organization}`
+        });
+        const cacheStats = await client.getCacheStats();
+        checks.push(healthChecker.checkCacheFromStats(cacheStats));
+        const registry = client.getTypeRegistry();
+        checks.push(healthChecker.checkTypesFromRegistry(registry));
+      } catch (error) {
+        checks.push({
+          name: "SDK Client",
+          status: "fail",
+          message: "Failed to initialize CodexClient",
+          details: error.message
+        });
+        checks.push({
+          name: "Cache",
+          status: "warn",
+          message: "Cache check skipped",
+          details: "SDK client not available"
+        });
+        checks.push({
+          name: "Type Registry",
+          status: "warn",
+          message: "Type registry check skipped",
+          details: "SDK client not available"
+        });
+      }
+      const result = healthChecker.summarize(checks);
       if (options.json) {
-        console.log(JSON.stringify({
-          summary: {
-            total: checks.length,
-            passed,
-            warned,
-            failed,
-            healthy: failed === 0
-          },
-          checks
-        }, null, 2));
+        console.log(JSON.stringify(result, null, 2));
         return;
       }
-      console.log(chalk7__default.default.bold("Codex Health Check\n"));
-      for (const check of checks) {
-        const icon = check.status === "pass" ? chalk7__default.default.green("\u2713") : check.status === "warn" ? chalk7__default.default.yellow("\u26A0") : chalk7__default.default.red("\u2717");
-        const statusColor = check.status === "pass" ? chalk7__default.default.green : check.status === "warn" ? chalk7__default.default.yellow : chalk7__default.default.red;
-        console.log(`${icon} ${chalk7__default.default.bold(check.name)}`);
+      console.log(chalk10__default.default.bold("Codex Health Check\n"));
+      for (const check of result.checks) {
+        const icon = check.status === "pass" ? chalk10__default.default.green("\u2713") : check.status === "warn" ? chalk10__default.default.yellow("\u26A0") : chalk10__default.default.red("\u2717");
+        const statusColor = check.status === "pass" ? chalk10__default.default.green : check.status === "warn" ? chalk10__default.default.yellow : chalk10__default.default.red;
+        console.log(`${icon} ${chalk10__default.default.bold(check.name)}`);
         console.log(`  ${statusColor(check.message)}`);
         if (check.details) {
-          console.log(`  ${chalk7__default.default.dim(check.details)}`);
+          console.log(`  ${chalk10__default.default.dim(check.details)}`);
         }
         console.log("");
       }
-      console.log(chalk7__default.default.dim("\u2500".repeat(60)));
-      const overallStatus = failed > 0 ? chalk7__default.default.red("UNHEALTHY") : warned > 0 ? chalk7__default.default.yellow("DEGRADED") : chalk7__default.default.green("HEALTHY");
+      console.log(chalk10__default.default.dim("\u2500".repeat(60)));
+      const overallStatus = result.summary.status === "unhealthy" ? chalk10__default.default.red("UNHEALTHY") : result.summary.status === "degraded" ? chalk10__default.default.yellow("DEGRADED") : chalk10__default.default.green("HEALTHY");
       console.log(`Status: ${overallStatus}`);
-      console.log(chalk7__default.default.dim(`${passed} passed, ${warned} warnings, ${failed} failed`));
-      if (failed > 0 || warned > 0) {
+      console.log(
+        chalk10__default.default.dim(`${result.summary.passed} passed, ${result.summary.warned} warnings, ${result.summary.failed} failed`)
+      );
+      if (result.summary.failed > 0 || result.summary.warned > 0) {
         console.log("");
-        console.log(chalk7__default.default.dim("Run checks individually for more details:"));
-        console.log(chalk7__default.default.dim("  fractary codex cache stats"));
-        console.log(chalk7__default.default.dim("  fractary codex types list"));
+        console.log(chalk10__default.default.dim("Run checks individually for more details:"));
+        console.log(chalk10__default.default.dim("  fractary-codex cache-stats"));
       }
-      if (failed > 0) {
+      if (result.summary.failed > 0) {
         process.exit(1);
       }
     } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
+      console.error(chalk10__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();
+
+// src/config/migrate-config.ts
+init_cjs_shims();
+
+// src/commands/sync.ts
 function getEnvironmentBranch(config, env) {
   const envMap = config.sync?.environments || {
     dev: "develop",
@@ -1787,26 +956,17 @@ function getEnvironmentBranch(config, env) {
   };
   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").option("--work-id <id>", "GitHub issue number or URL to scope sync to").action(async (name, options) => {
     try {
-      const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
+      const configPath = path3__namespace.join(process.cwd(), ".fractary", "config.yaml");
       let config;
       try {
         config = await codex.readCodexConfig(configPath);
       } catch (error) {
-        console.error(chalk7__default.default.red("Error:"), "Codex not initialized.");
-        console.log(chalk7__default.default.dim('Run "fractary codex init" first.'));
+        console.error(chalk10__default.default.red("Error:"), "Codex not initialized.");
+        console.log(chalk10__default.default.dim('Run "fractary-codex configure" first.'));
         process.exit(1);
       }
       const { createSyncManager, createLocalStorage, detectCurrentProject } = await import('@fractary/codex');
@@ -1819,14 +979,14 @@ function syncCommand() {
         projectName = detected.project || void 0;
       }
       if (!projectName) {
-        console.error(chalk7__default.default.red("Error:"), "Could not determine project name.");
-        console.log(chalk7__default.default.dim("Provide project name as argument, set codex.project in config, or run from a git repository."));
+        console.error(chalk10__default.default.red("Error:"), "Could not determine project name.");
+        console.log(chalk10__default.default.dim("Provide project name as argument, set codex.project in config, or run from a git repository."));
         process.exit(1);
       }
       const validDirections = ["to-codex", "from-codex", "bidirectional"];
       if (!validDirections.includes(options.direction)) {
-        console.error(chalk7__default.default.red("Error:"), `Invalid direction: ${options.direction}`);
-        console.log(chalk7__default.default.dim("Valid options: to-codex, from-codex, bidirectional"));
+        console.error(chalk10__default.default.red("Error:"), `Invalid direction: ${options.direction}`);
+        console.log(chalk10__default.default.dim("Valid options: to-codex, from-codex, bidirectional"));
         process.exit(1);
       }
       const direction = options.direction;
@@ -1837,7 +997,7 @@ function syncCommand() {
       const syncManager = createSyncManager({
         localStorage,
         config: config.sync,
-        manifestPath: path4__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
+        manifestPath: path3__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
       });
       const defaultToCodexPatterns = [
         "docs/**/*.md",
@@ -1867,13 +1027,13 @@ function syncCommand() {
           });
           matches.forEach((match) => matchedFilePaths.add(match));
         } catch (error) {
-          console.error(chalk7__default.default.yellow(`Warning: Invalid pattern "${pattern}": ${error.message}`));
+          console.error(chalk10__default.default.yellow(`Warning: Invalid pattern "${pattern}": ${error.message}`));
         }
       }
       const targetFiles = await Promise.all(
         Array.from(matchedFilePaths).map(async (filePath) => {
-          const fullPath = path4__namespace.join(sourceDir, filePath);
-          const stats = await import('fs/promises').then((fs8) => fs8.stat(fullPath));
+          const fullPath = path3__namespace.join(sourceDir, filePath);
+          const stats = await import('fs/promises').then((fs3) => fs3.stat(fullPath));
           return {
             path: filePath,
             size: stats.size,
@@ -1897,14 +1057,14 @@ function syncCommand() {
         try {
           const { ensureCodexCloned: ensureCodexCloned2 } = await Promise.resolve().then(() => (init_codex_repository(), codex_repository_exports));
           if (!options.json) {
-            console.log(chalk7__default.default.blue("\u2139 Cloning/updating codex repository..."));
+            console.log(chalk10__default.default.blue("\u2139 Cloning/updating codex repository..."));
           }
           codexRepoPath = await ensureCodexCloned2(config, {
             branch: targetBranch
           });
           if (!options.json) {
-            console.log(chalk7__default.default.dim(`  Codex cloned to: ${codexRepoPath}`));
-            console.log(chalk7__default.default.dim("  Scanning for files routing to this project...\n"));
+            console.log(chalk10__default.default.dim(`  Codex cloned to: ${codexRepoPath}`));
+            console.log(chalk10__default.default.dim("  Scanning for files routing to this project...\n"));
           } else {
             console.log(JSON.stringify({
               info: "Routing-aware sync: cloned codex repository and scanning for files targeting this project",
@@ -1912,29 +1072,29 @@ function syncCommand() {
             }, null, 2));
           }
         } catch (error) {
-          console.error(chalk7__default.default.red("Error:"), "Failed to clone codex repository");
-          console.error(chalk7__default.default.dim(`  ${error.message}`));
-          console.log(chalk7__default.default.yellow("\nTroubleshooting:"));
+          console.error(chalk10__default.default.red("Error:"), "Failed to clone codex repository");
+          console.error(chalk10__default.default.dim(`  ${error.message}`));
+          console.log(chalk10__default.default.yellow("\nTroubleshooting:"));
           if (error.message.includes("Git command not found")) {
-            console.log(chalk7__default.default.dim("  Git is not installed or not in PATH."));
-            console.log(chalk7__default.default.dim("  Install git: https://git-scm.com/downloads"));
+            console.log(chalk10__default.default.dim("  Git is not installed or not in PATH."));
+            console.log(chalk10__default.default.dim("  Install git: https://git-scm.com/downloads"));
           } else if (error.message.includes("authentication failed") || error.message.includes("Authentication failed")) {
-            console.log(chalk7__default.default.dim("  GitHub authentication is required for private repositories."));
-            console.log(chalk7__default.default.dim("  1. Check auth status: gh auth status"));
-            console.log(chalk7__default.default.dim("  2. Login if needed: gh auth login"));
-            console.log(chalk7__default.default.dim("  3. Or set GITHUB_TOKEN environment variable"));
+            console.log(chalk10__default.default.dim("  GitHub authentication is required for private repositories."));
+            console.log(chalk10__default.default.dim("  1. Check auth status: gh auth status"));
+            console.log(chalk10__default.default.dim("  2. Login if needed: gh auth login"));
+            console.log(chalk10__default.default.dim("  3. Or set GITHUB_TOKEN environment variable"));
           } else if (error.message.includes("Permission denied")) {
-            console.log(chalk7__default.default.dim("  Permission denied accessing repository files."));
-            console.log(chalk7__default.default.dim("  1. Check file/directory permissions"));
-            console.log(chalk7__default.default.dim("  2. Ensure you have access to the repository"));
+            console.log(chalk10__default.default.dim("  Permission denied accessing repository files."));
+            console.log(chalk10__default.default.dim("  1. Check file/directory permissions"));
+            console.log(chalk10__default.default.dim("  2. Ensure you have access to the repository"));
           } else if (error.message.includes("not found") || error.message.includes("does not exist")) {
-            console.log(chalk7__default.default.dim(`  Repository not found: ${config.organization}/${config.codex_repo || "codex"}`));
-            console.log(chalk7__default.default.dim("  1. Verify the repository exists on GitHub"));
-            console.log(chalk7__default.default.dim("  2. Check organization and repository names in config"));
+            console.log(chalk10__default.default.dim(`  Repository not found: ${config.organization}/${config.codex_repo || "codex"}`));
+            console.log(chalk10__default.default.dim("  1. Verify the repository exists on GitHub"));
+            console.log(chalk10__default.default.dim("  2. Check organization and repository names in config"));
           } else {
-            console.log(chalk7__default.default.dim("  1. Ensure git is installed: git --version"));
-            console.log(chalk7__default.default.dim("  2. Check GitHub auth: gh auth status"));
-            console.log(chalk7__default.default.dim(`  3. Verify repo exists: ${config.organization}/${config.codex_repo || "codex"}`));
+            console.log(chalk10__default.default.dim("  1. Ensure git is installed: git --version"));
+            console.log(chalk10__default.default.dim("  2. Check GitHub auth: gh auth status"));
+            console.log(chalk10__default.default.dim(`  3. Verify repo exists: ${config.organization}/${config.codex_repo || "codex"}`));
           }
           process.exit(1);
         }
@@ -1953,17 +1113,17 @@ function syncCommand() {
         try {
           const { ensureCodexCloned: ensureCodexCloned2 } = await Promise.resolve().then(() => (init_codex_repository(), codex_repository_exports));
           if (!options.json) {
-            console.log(chalk7__default.default.blue("\u2139 Cloning/updating codex repository..."));
+            console.log(chalk10__default.default.blue("\u2139 Cloning/updating codex repository..."));
           }
           codexRepoPath = await ensureCodexCloned2(config, {
             branch: targetBranch
           });
           if (!options.json) {
-            console.log(chalk7__default.default.dim(`  Codex cloned to: ${codexRepoPath}`));
+            console.log(chalk10__default.default.dim(`  Codex cloned to: ${codexRepoPath}`));
           }
         } catch (error) {
-          console.error(chalk7__default.default.red("Error:"), "Failed to clone codex repository");
-          console.error(chalk7__default.default.dim(`  ${error.message}`));
+          console.error(chalk10__default.default.red("Error:"), "Failed to clone codex repository");
+          console.error(chalk10__default.default.dim(`  ${error.message}`));
           process.exit(1);
         }
         plan = await syncManager.createPlan(
@@ -1975,7 +1135,7 @@ function syncCommand() {
           syncOptions
         );
         plan.source = sourceDir;
-        plan.target = path4__namespace.join(codexRepoPath, "projects", projectName);
+        plan.target = path3__namespace.join(codexRepoPath, "projects", projectName);
       }
       if (plan.totalFiles === 0) {
         if (options.json) {
@@ -1989,7 +1149,7 @@ function syncCommand() {
             message: "No files to sync"
           }, null, 2));
         } else {
-          console.log(chalk7__default.default.yellow("No files to sync."));
+          console.log(chalk10__default.default.yellow("No files to sync."));
         }
         return;
       }
@@ -2045,81 +1205,81 @@ function syncCommand() {
         }, null, 2));
         return;
       }
-      console.log(chalk7__default.default.bold("Sync Plan\n"));
-      console.log(`  Project:      ${chalk7__default.default.cyan(projectName)}`);
-      console.log(`  Organization: ${chalk7__default.default.cyan(config.organization)}`);
-      console.log(`  Environment:  ${chalk7__default.default.cyan(options.env)} (${targetBranch})`);
-      console.log(`  Direction:    ${chalk7__default.default.cyan(direction)}`);
-      console.log(`  Files:        ${chalk7__default.default.cyan(plan.totalFiles.toString())}`);
-      console.log(`  Total size:   ${chalk7__default.default.cyan(formatBytes(plan.totalBytes))}`);
+      console.log(chalk10__default.default.bold("Sync Plan\n"));
+      console.log(`  Project:      ${chalk10__default.default.cyan(projectName)}`);
+      console.log(`  Organization: ${chalk10__default.default.cyan(config.organization)}`);
+      console.log(`  Environment:  ${chalk10__default.default.cyan(options.env)} (${targetBranch})`);
+      console.log(`  Direction:    ${chalk10__default.default.cyan(direction)}`);
+      console.log(`  Files:        ${chalk10__default.default.cyan(plan.totalFiles.toString())}`);
+      console.log(`  Total size:   ${chalk10__default.default.cyan(codex.formatBytes(plan.totalBytes))}`);
       if (plan.estimatedTime) {
-        console.log(`  Est. time:    ${chalk7__default.default.dim(formatDuration(plan.estimatedTime))}`);
+        console.log(`  Est. time:    ${chalk10__default.default.dim(codex.formatDuration(plan.estimatedTime))}`);
       }
       if (routingScan) {
         console.log("");
-        console.log(chalk7__default.default.bold("Routing Statistics\n"));
-        console.log(`  Scanned:      ${chalk7__default.default.cyan(routingScan.stats.totalScanned.toString())} files`);
-        console.log(`  Matched:      ${chalk7__default.default.cyan(routingScan.stats.totalMatched.toString())} files`);
-        console.log(`  Source projects: ${chalk7__default.default.cyan(routingScan.stats.sourceProjects.length.toString())}`);
+        console.log(chalk10__default.default.bold("Routing Statistics\n"));
+        console.log(`  Scanned:      ${chalk10__default.default.cyan(routingScan.stats.totalScanned.toString())} files`);
+        console.log(`  Matched:      ${chalk10__default.default.cyan(routingScan.stats.totalMatched.toString())} files`);
+        console.log(`  Source projects: ${chalk10__default.default.cyan(routingScan.stats.sourceProjects.length.toString())}`);
         if (routingScan.stats.sourceProjects.length > 0) {
-          console.log(chalk7__default.default.dim(`    ${routingScan.stats.sourceProjects.slice(0, 5).join(", ")}`));
+          console.log(chalk10__default.default.dim(`    ${routingScan.stats.sourceProjects.slice(0, 5).join(", ")}`));
           if (routingScan.stats.sourceProjects.length > 5) {
-            console.log(chalk7__default.default.dim(`    ... and ${routingScan.stats.sourceProjects.length - 5} more`));
+            console.log(chalk10__default.default.dim(`    ... and ${routingScan.stats.sourceProjects.length - 5} more`));
           }
         }
-        console.log(`  Scan time:    ${chalk7__default.default.dim(formatDuration(routingScan.stats.durationMs))}`);
+        console.log(`  Scan time:    ${chalk10__default.default.dim(codex.formatDuration(routingScan.stats.durationMs))}`);
       }
       console.log("");
       if (plan.conflicts.length > 0) {
-        console.log(chalk7__default.default.yellow(`\u26A0 ${plan.conflicts.length} conflicts detected:`));
+        console.log(chalk10__default.default.yellow(`\u26A0 ${plan.conflicts.length} conflicts detected:`));
         for (const conflict of plan.conflicts.slice(0, 5)) {
-          console.log(chalk7__default.default.yellow(`  \u2022 ${conflict.path}`));
+          console.log(chalk10__default.default.yellow(`  \u2022 ${conflict.path}`));
         }
         if (plan.conflicts.length > 5) {
-          console.log(chalk7__default.default.dim(`  ... and ${plan.conflicts.length - 5} more`));
+          console.log(chalk10__default.default.dim(`  ... and ${plan.conflicts.length - 5} more`));
         }
         console.log("");
       }
       if (plan.skipped.length > 0) {
-        console.log(chalk7__default.default.dim(`${plan.skipped.length} files skipped (no changes)`));
+        console.log(chalk10__default.default.dim(`${plan.skipped.length} files skipped (no changes)`));
         console.log("");
       }
       if (options.dryRun) {
-        console.log(chalk7__default.default.blue("Dry run - would sync:\n"));
+        console.log(chalk10__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" ? chalk7__default.default.green : file.operation === "update" ? chalk7__default.default.yellow : chalk7__default.default.dim;
+          const opColor = file.operation === "create" ? chalk10__default.default.green : file.operation === "update" ? chalk10__default.default.yellow : chalk10__default.default.dim;
           console.log(
-            chalk7__default.default.dim(`  ${arrow}`),
+            chalk10__default.default.dim(`  ${arrow}`),
             opColor(file.operation.padEnd(7)),
             file.path,
-            chalk7__default.default.dim(`(${formatBytes(file.size || 0)})`)
+            chalk10__default.default.dim(`(${codex.formatBytes(file.size || 0)})`)
           );
         }
         if (plan.files.length > 10) {
-          console.log(chalk7__default.default.dim(`  ... and ${plan.files.length - 10} more files`));
+          console.log(chalk10__default.default.dim(`  ... and ${plan.files.length - 10} more files`));
         }
-        console.log(chalk7__default.default.dim(`
-Total: ${plan.totalFiles} files (${formatBytes(plan.totalBytes)})`));
-        console.log(chalk7__default.default.dim("Run without --dry-run to execute sync."));
+        console.log(chalk10__default.default.dim(`
+Total: ${plan.totalFiles} files (${codex.formatBytes(plan.totalBytes)})`));
+        console.log(chalk10__default.default.dim("Run without --dry-run to execute sync."));
         return;
       }
-      console.log(chalk7__default.default.blue("Syncing...\n"));
+      console.log(chalk10__default.default.blue("Syncing...\n"));
       const startTime = Date.now();
       const result = await syncManager.executePlan(plan, syncOptions);
       const duration = Date.now() - startTime;
       if (direction === "to-codex" && codexRepoPath && result.synced > 0) {
         try {
           if (!options.json) {
-            console.log(chalk7__default.default.blue("Committing and pushing to codex..."));
+            console.log(chalk10__default.default.blue("Committing and pushing to codex..."));
           }
           const { RepoManager } = await import('@fractary/core/repo');
           const repoManager = new RepoManager({ platform: "github" }, codexRepoPath);
           repoManager.stageAll();
           if (repoManager.isClean()) {
             if (!options.json) {
-              console.log(chalk7__default.default.dim("  No changes to push - codex is already up to date"));
+              console.log(chalk10__default.default.dim("  No changes to push - codex is already up to date"));
             }
           } else {
             repoManager.commit({
@@ -2127,401 +1287,62 @@ Total: ${plan.totalFiles} files (${formatBytes(plan.totalBytes)})`));
             });
             repoManager.push({});
             if (!options.json) {
-              console.log(chalk7__default.default.dim("  Changes pushed to codex repository"));
+              console.log(chalk10__default.default.dim("  Changes pushed to codex repository"));
             }
           }
         } catch (error) {
-          console.error(chalk7__default.default.red("Error pushing to codex:"), error.message);
+          console.error(chalk10__default.default.red("Error pushing to codex:"), error.message);
         }
       }
       console.log("");
       if (result.success) {
-        console.log(chalk7__default.default.green(`\u2713 Sync completed successfully`));
-        console.log(chalk7__default.default.dim(`  Synced: ${result.synced} files`));
+        console.log(chalk10__default.default.green(`\u2713 Sync completed successfully`));
+        console.log(chalk10__default.default.dim(`  Synced: ${result.synced} files`));
         if (result.skipped > 0) {
-          console.log(chalk7__default.default.dim(`  Skipped: ${result.skipped} files`));
+          console.log(chalk10__default.default.dim(`  Skipped: ${result.skipped} files`));
         }
-        console.log(chalk7__default.default.dim(`  Duration: ${formatDuration(duration)}`));
+        console.log(chalk10__default.default.dim(`  Duration: ${codex.formatDuration(duration)}`));
       } else {
-        console.log(chalk7__default.default.yellow(`\u26A0 Sync completed with errors`));
-        console.log(chalk7__default.default.green(`  Synced: ${result.synced} files`));
-        console.log(chalk7__default.default.red(`  Failed: ${result.failed} files`));
+        console.log(chalk10__default.default.yellow(`\u26A0 Sync completed with errors`));
+        console.log(chalk10__default.default.green(`  Synced: ${result.synced} files`));
+        console.log(chalk10__default.default.red(`  Failed: ${result.failed} files`));
         if (result.skipped > 0) {
-          console.log(chalk7__default.default.dim(`  Skipped: ${result.skipped} files`));
+          console.log(chalk10__default.default.dim(`  Skipped: ${result.skipped} files`));
         }
         if (result.errors.length > 0) {
           console.log("");
-          console.log(chalk7__default.default.red("Errors:"));
+          console.log(chalk10__default.default.red("Errors:"));
           for (const error of result.errors.slice(0, 5)) {
-            console.log(chalk7__default.default.red(`  \u2022 ${error.path}: ${error.error}`));
+            console.log(chalk10__default.default.red(`  \u2022 ${error.path}: ${error.error}`));
           }
           if (result.errors.length > 5) {
-            console.log(chalk7__default.default.dim(`  ... and ${result.errors.length - 5} more errors`));
+            console.log(chalk10__default.default.dim(`  ... and ${result.errors.length - 5} more errors`));
           }
         }
       }
     } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-
-// src/commands/types/index.ts
-init_cjs_shims();
-
-// src/commands/types/list.ts
-init_cjs_shims();
-function formatTtl(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 typesListCommand() {
-  const cmd = new commander.Command("list");
-  cmd.description("List all artifact types").option("--json", "Output as JSON").option("--custom-only", "Show only custom types").option("--builtin-only", "Show only built-in types").action(async (options) => {
-    try {
-      const client = await getClient();
-      const registry = client.getTypeRegistry();
-      const allTypes = registry.list();
-      let types = allTypes;
-      if (options.customOnly) {
-        types = allTypes.filter((t) => !registry.isBuiltIn(t.name));
-      } else if (options.builtinOnly) {
-        types = allTypes.filter((t) => registry.isBuiltIn(t.name));
-      }
-      if (options.json) {
-        const builtinCount = types.filter((t) => registry.isBuiltIn(t.name)).length;
-        const customCount = types.length - builtinCount;
-        console.log(JSON.stringify({
-          count: types.length,
-          builtinCount,
-          customCount,
-          types: types.map((t) => ({
-            name: t.name,
-            description: t.description,
-            patterns: t.patterns,
-            defaultTtl: t.defaultTtl,
-            ttl: formatTtl(t.defaultTtl),
-            builtin: registry.isBuiltIn(t.name),
-            archiveAfterDays: t.archiveAfterDays,
-            archiveStorage: t.archiveStorage
-          }))
-        }, null, 2));
-        return;
-      }
-      if (types.length === 0) {
-        console.log(chalk7__default.default.yellow("No types found."));
-        return;
-      }
-      console.log(chalk7__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(chalk7__default.default.bold("Built-in Types"));
-        console.log(chalk7__default.default.dim("\u2500".repeat(70)));
-        for (const type of builtinTypes) {
-          const patternStr = type.patterns[0] || "";
-          console.log(`  ${chalk7__default.default.cyan(type.name.padEnd(12))} ${patternStr.padEnd(30)} ${chalk7__default.default.dim(`TTL: ${formatTtl(type.defaultTtl)}`)}`);
-          console.log(`  ${chalk7__default.default.dim(" ".repeat(12) + type.description)}`);
-        }
-        console.log("");
-      }
-      if (customTypes.length > 0 && !options.builtinOnly) {
-        console.log(chalk7__default.default.bold("Custom Types"));
-        console.log(chalk7__default.default.dim("\u2500".repeat(70)));
-        for (const type of customTypes) {
-          const patternStr = type.patterns[0] || "";
-          console.log(`  ${chalk7__default.default.green(type.name.padEnd(12))} ${patternStr.padEnd(30)} ${chalk7__default.default.dim(`TTL: ${formatTtl(type.defaultTtl)}`)}`);
-          console.log(`  ${chalk7__default.default.dim(" ".repeat(12) + type.description)}`);
-        }
-        console.log("");
-      }
-      console.log(chalk7__default.default.dim(`Total: ${types.length} types (${builtinTypes.length} built-in, ${customTypes.length} custom)`));
-    } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-
-// src/commands/types/show.ts
-init_cjs_shims();
-function formatTtl2(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 typesShowCommand() {
-  const cmd = new commander.Command("show");
-  cmd.description("Show details for a specific type").argument("<name>", "Type name").option("--json", "Output as JSON").action(async (name, options) => {
-    try {
-      const client = await getClient();
-      const registry = client.getTypeRegistry();
-      const type = registry.get(name);
-      if (!type) {
-        console.error(chalk7__default.default.red("Error:"), `Type "${name}" not found.`);
-        console.log(chalk7__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 ? chalk7__default.default.cyan : chalk7__default.default.green;
-      console.log(chalk7__default.default.bold(`Type: ${nameColor(name)}
-`));
-      console.log(`  ${chalk7__default.default.dim("Source:")}      ${isBuiltin ? "Built-in" : "Custom"}`);
-      console.log(`  ${chalk7__default.default.dim("Description:")} ${type.description}`);
-      console.log(`  ${chalk7__default.default.dim("TTL:")}         ${formatTtl2(type.defaultTtl)} (${type.defaultTtl} seconds)`);
-      console.log("");
-      console.log(chalk7__default.default.bold("Patterns"));
-      for (const pattern of type.patterns) {
-        console.log(`  ${chalk7__default.default.dim("\u2022")} ${pattern}`);
-      }
-      if (type.archiveAfterDays !== null) {
-        console.log("");
-        console.log(chalk7__default.default.bold("Archive Settings"));
-        console.log(`  ${chalk7__default.default.dim("After:")}   ${type.archiveAfterDays} days`);
-        console.log(`  ${chalk7__default.default.dim("Storage:")} ${type.archiveStorage || "not set"}`);
-      }
-      if (type.syncPatterns && type.syncPatterns.length > 0) {
-        console.log("");
-        console.log(chalk7__default.default.bold("Sync Patterns"));
-        for (const pattern of type.syncPatterns) {
-          console.log(`  ${chalk7__default.default.dim("\u2022")} ${pattern}`);
-        }
-      }
-      if (type.excludePatterns && type.excludePatterns.length > 0) {
-        console.log("");
-        console.log(chalk7__default.default.bold("Exclude Patterns"));
-        for (const pattern of type.excludePatterns) {
-          console.log(`  ${chalk7__default.default.dim("\u2022")} ${pattern}`);
-        }
-      }
-    } catch (error) {
-      console.error(chalk7__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(chalk7__default.default.red("Error:"), "Invalid type name.");
-        console.log(chalk7__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(chalk7__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(chalk7__default.default.dim("Built-in types: " + builtinNames.join(", ")));
-        process.exit(1);
-      }
-      if (registry.has(name)) {
-        console.error(chalk7__default.default.red("Error:"), `Custom type "${name}" already exists.`);
-        console.log(chalk7__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(chalk7__default.default.red("Error:"), "Invalid TTL format.");
-        console.log(chalk7__default.default.dim("Expected format: <number><unit> where unit is s (seconds), m (minutes), h (hours), or d (days)"));
-        console.log(chalk7__default.default.dim("Examples: 30m, 24h, 7d"));
-        process.exit(1);
-      }
-      const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
-      const config = await codex.readCodexConfig(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(chalk7__default.default.green("\u2713"), `Added custom type "${chalk7__default.default.cyan(name)}"`);
-      console.log("");
-      console.log(`  ${chalk7__default.default.dim("Pattern:")}     ${options.pattern}`);
-      console.log(`  ${chalk7__default.default.dim("TTL:")}         ${formatTtl3(ttlSeconds)} (${ttlSeconds} seconds)`);
-      if (options.description) {
-        console.log(`  ${chalk7__default.default.dim("Description:")} ${options.description}`);
-      }
-      console.log("");
-      console.log(chalk7__default.default.dim("Note: Custom type will be available on next CLI invocation."));
-    } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
-      if (error.message.includes("Failed to load configuration")) {
-        console.log(chalk7__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(chalk7__default.default.red("Error:"), `Cannot remove built-in type "${name}".`);
-        console.log(chalk7__default.default.dim("Built-in types are permanent and cannot be removed."));
-        process.exit(1);
-      }
-      if (!registry.has(name)) {
-        console.error(chalk7__default.default.red("Error:"), `Custom type "${name}" not found.`);
-        console.log(chalk7__default.default.dim('Run "fractary codex types list --custom-only" to see custom types.'));
-        process.exit(1);
-      }
-      const typeInfo = registry.get(name);
-      const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
-      const config = await codex.readCodexConfig(configPath);
-      if (!config.types?.custom?.[name]) {
-        console.error(chalk7__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(chalk7__default.default.green("\u2713"), `Removed custom type "${chalk7__default.default.cyan(name)}"`);
-      console.log("");
-      console.log(chalk7__default.default.dim("Removed configuration:"));
-      console.log(`  ${chalk7__default.default.dim("Pattern:")}     ${typeInfo.patterns.join(", ")}`);
-      console.log(`  ${chalk7__default.default.dim("Description:")} ${typeInfo.description}`);
-      console.log("");
-      console.log(chalk7__default.default.dim("Note: Custom type will be removed on next CLI invocation."));
-    } catch (error) {
-      console.error(chalk7__default.default.red("Error:"), error.message);
-      if (error.message.includes("Failed to load configuration")) {
-        console.log(chalk7__default.default.dim('\nRun "fractary codex init" to create a configuration.'));
-      }
+      console.error(chalk10__default.default.red("Error:"), error.message);
       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;
-}
 var __filename2 = url.fileURLToPath(importMetaUrl);
-var __dirname$1 = path4.dirname(__filename2);
-var packageJson = JSON.parse(fs.readFileSync(path4.join(__dirname$1, "../package.json"), "utf-8"));
+var __dirname$1 = path3.dirname(__filename2);
+var packageJson = JSON.parse(fs.readFileSync(path3.join(__dirname$1, "../package.json"), "utf-8"));
 var VERSION = packageJson.version;
 function createCLI() {
   const program = new commander.Command("fractary-codex");
   program.description("Centralized knowledge management and distribution for AI agents").version(VERSION);
-  program.addCommand(documentCommand());
-  program.addCommand(configCommand());
-  program.addCommand(cacheCommand());
+  program.addCommand(configInitializeCommand());
+  program.addCommand(configUpdateCommand());
+  program.addCommand(configValidateCommand());
+  program.addCommand(documentFetchCommand());
+  program.addCommand(cacheListCommand());
+  program.addCommand(cacheClearCommand());
+  program.addCommand(cacheStatsCommand());
+  program.addCommand(cacheHealthCommand());
   program.addCommand(syncCommand());
-  program.addCommand(typesCommand());
   return program;
 }
 async function main() {