@fractary/codex-cli 0.10.14 → 0.10.16

package/dist/cli.cjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 'use strict';
 
-var fs$1 = require('fs/promises');
-var path4 = require('path');
-var yaml2 = require('js-yaml');
+var fs4 = require('fs/promises');
+var path2 = require('path');
+var yaml = require('js-yaml');
 var codex = require('@fractary/codex');
 var os = require('os');
 var child_process = require('child_process');
@@ -33,9 +33,9 @@ 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 fs4__namespace = /*#__PURE__*/_interopNamespace(fs4);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var chalk7__default = /*#__PURE__*/_interopDefault(chalk7);
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
@@ -76,7 +76,7 @@ __export(migrate_config_exports, {
 });
 async function isLegacyConfig(configPath) {
   try {
-    const content = await fs__namespace.readFile(configPath, "utf-8");
+    const content = await fs4__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 {
@@ -86,13 +86,13 @@ async function isLegacyConfig(configPath) {
 async function migrateConfig(legacyConfigPath, options) {
   const warnings = [];
   try {
-    const content = await fs__namespace.readFile(legacyConfigPath, "utf-8");
+    const content = await fs4__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");
+      await fs4__namespace.writeFile(backupPath, content, "utf-8");
     }
     const yamlConfig = {
       organization: legacy.organization || legacy.organizationSlug || "default"
@@ -194,15 +194,15 @@ async function migrateConfig(legacyConfigPath, options) {
   }
 }
 async function writeYamlConfig(config, outputPath) {
-  const dir = path4__namespace.dirname(outputPath);
-  await fs__namespace.mkdir(dir, { recursive: true });
-  const yamlContent = yaml2__namespace.dump(config, {
+  const dir = path2__namespace.dirname(outputPath);
+  await fs4__namespace.mkdir(dir, { recursive: true });
+  const yamlContent = yaml__namespace.dump(config, {
     indent: 2,
     lineWidth: 80,
     noRefs: true,
     sortKeys: false
   });
-  await fs__namespace.writeFile(outputPath, yamlContent, "utf-8");
+  await fs4__namespace.writeFile(outputPath, yamlContent, "utf-8");
 }
 function getDefaultYamlConfig(organization) {
   return {
@@ -330,14 +330,14 @@ var init_codex_client = __esm({
         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");
+          const configPath = path2__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.`
+              `Failed to load configuration from ${configPath}. Run "fractary-codex configure" to create a configuration.`
             );
           }
           const organization = options?.organizationSlug || config.organization;
@@ -600,7 +600,7 @@ function getTempCodexPath(config) {
   const codexRepo = config.codex_repo || "codex";
   const sanitizedOrg = sanitizePathComponent(config.organization);
   const sanitizedRepo = sanitizePathComponent(codexRepo);
-  return path4__namespace.join(
+  return path2__namespace.join(
     os__namespace.tmpdir(),
     "fractary-codex-clone",
     `${sanitizedOrg}-${sanitizedRepo}-${process.pid}`
@@ -608,8 +608,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 = path2__namespace.join(repoPath, ".git");
+    const stats = await fs4__namespace.stat(gitDir);
     return stats.isDirectory();
   } catch {
     return false;
@@ -641,8 +641,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 = path2__namespace.dirname(targetPath);
+  await fs4__namespace.mkdir(parentDir, { recursive: true });
   const args = ["clone"];
   if (options?.depth) {
     if (!Number.isInteger(options.depth) || options.depth <= 0) {
@@ -689,12 +689,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 fs4__namespace.rm(tempPath, { recursive: true, force: true });
     }
   }
   const repoUrl = getCodexRepoUrl(config);
   try {
-    await fs__namespace.rm(tempPath, { recursive: true, force: true });
+    await fs4__namespace.rm(tempPath, { recursive: true, force: true });
   } catch (error) {
     console.warn(`Could not remove existing directory ${tempPath}: ${error.message}`);
   }
@@ -714,100 +714,6 @@ var init_codex_repository = __esm({
 // src/cli.ts
 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;
-}
-
-// src/commands/document/fetch.ts
-function hashContent(content) {
-  return crypto__namespace.createHash("sha256").update(content).digest("hex").slice(0, 16);
-}
-function fetchCommand() {
-  const cmd = new commander.Command("fetch");
-  cmd.description("Fetch a document by codex:// URI reference").argument("<uri>", "Codex URI (e.g., codex://org/project/docs/file.md)").option("--bypass-cache", "Skip cache and fetch directly from source").option("--ttl <seconds>", "Override default TTL (in seconds)", parseInt).option("--json", "Output as JSON with metadata").option("--output <file>", "Write content to file instead of stdout").action(async (uri, options) => {
-    try {
-      const { validateUri } = await import('@fractary/codex');
-      if (!validateUri(uri)) {
-        console.error(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"));
-        process.exit(1);
-      }
-      const client = await getClient();
-      if (!options.json && !options.bypassCache) {
-        console.error(chalk7__default.default.dim(`Fetching ${uri}...`));
-      }
-      const result = await client.fetch(uri, {
-        bypassCache: options.bypassCache,
-        ttl: options.ttl
-      });
-      if (options.json) {
-        const output = {
-          uri,
-          content: result.content.toString("utf-8"),
-          metadata: {
-            fromCache: result.fromCache,
-            fetchedAt: result.metadata?.fetchedAt,
-            expiresAt: result.metadata?.expiresAt,
-            contentLength: result.metadata?.contentLength || result.content.length,
-            contentHash: hashContent(result.content)
-          }
-        };
-        console.log(JSON.stringify(output, null, 2));
-      } else if (options.output) {
-        await fs__namespace.writeFile(options.output, result.content);
-        console.log(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"));
-        }
-      } 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"));
-        }
-        console.log(result.content.toString("utf-8"));
-      }
-    } 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."));
-      }
-      process.exit(1);
-    }
-  });
-  return cmd;
-}
-
-// src/commands/document/index.ts
-function documentCommand() {
-  const cmd = new commander.Command("document");
-  cmd.description("Manage document operations");
-  cmd.addCommand(fetchCommand());
-  return cmd;
-}
-
 // src/commands/config/index.ts
 init_cjs_shims();
 
@@ -875,8 +781,8 @@ function getDefaultUnifiedConfig(organization, project, codexRepo) {
 }
 async function readUnifiedConfig(configPath) {
   try {
-    const content = await fs__namespace.readFile(configPath, "utf-8");
-    const config = yaml2__namespace.load(content);
+    const content = await fs4__namespace.readFile(configPath, "utf-8");
+    const config = yaml__namespace.load(content);
     return config;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -886,15 +792,15 @@ async function readUnifiedConfig(configPath) {
   }
 }
 async function writeUnifiedConfig(config, outputPath) {
-  const dir = path4__namespace.dirname(outputPath);
-  await fs__namespace.mkdir(dir, { recursive: true });
-  const yamlContent = yaml2__namespace.dump(config, {
+  const dir = path2__namespace.dirname(outputPath);
+  await fs4__namespace.mkdir(dir, { recursive: true });
+  const yamlContent = yaml__namespace.dump(config, {
     indent: 2,
     lineWidth: 120,
     noRefs: true,
     sortKeys: false
   });
-  await fs__namespace.writeFile(outputPath, yamlContent, "utf-8");
+  await fs4__namespace.writeFile(outputPath, yamlContent, "utf-8");
 }
 function mergeUnifiedConfigs(existing, updates) {
   const merged = {};
@@ -952,9 +858,9 @@ codex/cache/
 # ===== end fractary-codex =====
 `;
 async function readFractaryGitignore(projectRoot) {
-  const gitignorePath = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
+  const gitignorePath = path2__namespace.join(projectRoot, ".fractary", ".gitignore");
   try {
-    return await fs__namespace.readFile(gitignorePath, "utf-8");
+    return await fs4__namespace.readFile(gitignorePath, "utf-8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -963,9 +869,9 @@ async function readFractaryGitignore(projectRoot) {
   }
 }
 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");
+  const gitignorePath = path2__namespace.join(projectRoot, ".fractary", ".gitignore");
+  await fs4__namespace.mkdir(path2__namespace.join(projectRoot, ".fractary"), { recursive: true });
+  await fs4__namespace.writeFile(gitignorePath, content, "utf-8");
 }
 function normalizeCachePath(cachePath) {
   let normalized = cachePath.replace(/\\/g, "/");
@@ -1002,10 +908,10 @@ function addCachePathToGitignore(gitignoreContent, cachePath, comment) {
   return gitignoreContent.trimEnd() + addition;
 }
 async function ensureCachePathIgnored(projectRoot, cachePath) {
-  const gitignorePath = path4__namespace.join(projectRoot, ".fractary", ".gitignore");
+  const gitignorePath = path2__namespace.join(projectRoot, ".fractary", ".gitignore");
   let relativeCachePath = cachePath;
-  if (path4__namespace.isAbsolute(cachePath)) {
-    relativeCachePath = path4__namespace.relative(path4__namespace.join(projectRoot, ".fractary"), cachePath);
+  if (path2__namespace.isAbsolute(cachePath)) {
+    relativeCachePath = path2__namespace.relative(path2__namespace.join(projectRoot, ".fractary"), cachePath);
   }
   relativeCachePath = normalizeCachePath(relativeCachePath);
   let content = await readFractaryGitignore(projectRoot);
@@ -1123,27 +1029,27 @@ async function discoverCodexRepo(org) {
 }
 async function fileExists(filePath) {
   try {
-    await fs__namespace.access(filePath);
+    await fs4__namespace.access(filePath);
     return true;
   } catch {
     return false;
   }
 }
 async function installMcpServer(projectRoot, configPath = ".fractary/config.yaml", options = {}) {
-  const mcpJsonPath = path4__namespace.join(projectRoot, ".mcp.json");
+  const mcpJsonPath = path2__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");
+      const content = await fs4__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);
+        await fs4__namespace.writeFile(backupPath, content);
       }
     } catch {
       console.log(chalk7__default.default.yellow("\u26A0 Warning: .mcp.json contains invalid JSON, starting fresh"));
@@ -1173,7 +1079,7 @@ async function installMcpServer(projectRoot, configPath = ".fractary/config.yaml
     command: "npx",
     args: ["-y", "@fractary/codex-mcp", "--config", configPath]
   };
-  await fs__namespace.writeFile(
+  await fs4__namespace.writeFile(
     mcpJsonPath,
     JSON.stringify(existingConfig, null, 2) + "\n"
   );
@@ -1184,8 +1090,8 @@ async function installMcpServer(projectRoot, configPath = ".fractary/config.yaml
     backupPath
   };
 }
-function initCommand() {
-  const cmd = new commander.Command("init");
+function configureCommand() {
+  const cmd = new commander.Command("configure");
   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) => {
     try {
       console.log(chalk7__default.default.blue("Initializing unified Fractary configuration...\n"));
@@ -1197,13 +1103,13 @@ function initCommand() {
         try {
           const { resolveOrganization } = await import('@fractary/codex');
           org = resolveOrganization({
-            repoName: path4__namespace.basename(process.cwd())
+            repoName: path2__namespace.basename(process.cwd())
           });
         } catch {
         }
       }
       if (!org) {
-        org = path4__namespace.basename(process.cwd()).split("-")[0] || "default";
+        org = path2__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 {
@@ -1218,7 +1124,7 @@ function initCommand() {
       }
       let project = options.project;
       if (!project) {
-        project = path4__namespace.basename(process.cwd());
+        project = path2__namespace.basename(process.cwd());
         console.log(chalk7__default.default.dim(`Project: ${chalk7__default.default.cyan(project)}
 `));
       }
@@ -1259,7 +1165,7 @@ function initCommand() {
         console.log(chalk7__default.default.dim(`  Using default: ${chalk7__default.default.cyan(codexRepo)}
 `));
       }
-      const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
+      const configPath = path2__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`));
@@ -1274,7 +1180,7 @@ function initCommand() {
         ".fractary/codex/cache"
       ];
       for (const dir of dirs) {
-        await fs__namespace.mkdir(path4__namespace.join(process.cwd(), dir), { recursive: true });
+        await fs4__namespace.mkdir(path2__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");
@@ -1306,7 +1212,7 @@ function initCommand() {
         } 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)}`));
+            console.log(chalk7__default.default.dim(`  Backup: ${path2__namespace.basename(mcpResult.backupPath)}`));
           }
         } else if (mcpResult.installed) {
           console.log(chalk7__default.default.green("\u2713"), chalk7__default.default.dim(".mcp.json (created)"));
@@ -1344,11 +1250,89 @@ function initCommand() {
   return cmd;
 }
 
-// src/commands/config/index.ts
-function configCommand() {
-  const cmd = new commander.Command("config");
-  cmd.description("Manage configuration");
-  cmd.addCommand(initCommand());
+// src/commands/document/index.ts
+init_cjs_shims();
+
+// src/commands/document/fetch.ts
+init_cjs_shims();
+
+// src/client/get-client.ts
+init_cjs_shims();
+var clientInstance = null;
+async function getClient(options) {
+  if (!clientInstance) {
+    const { CodexClient: CodexClient2 } = await Promise.resolve().then(() => (init_codex_client(), codex_client_exports));
+    clientInstance = await CodexClient2.create(options);
+  }
+  return clientInstance;
+}
+
+// src/commands/document/fetch.ts
+function hashContent(content) {
+  return crypto__namespace.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function 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 {
+      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"));
+        process.exit(1);
+      }
+      const client = await getClient();
+      if (!options.json && !options.bypassCache) {
+        console.error(chalk7__default.default.dim(`Fetching ${uri}...`));
+      }
+      const result = await client.fetch(uri, {
+        bypassCache: options.bypassCache,
+        ttl: options.ttl
+      });
+      if (options.json) {
+        const output = {
+          uri,
+          content: result.content.toString("utf-8"),
+          metadata: {
+            fromCache: result.fromCache,
+            fetchedAt: result.metadata?.fetchedAt,
+            expiresAt: result.metadata?.expiresAt,
+            contentLength: result.metadata?.contentLength || result.content.length,
+            contentHash: hashContent(result.content)
+          }
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else if (options.output) {
+        await fs4__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"));
+        }
+      } 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"));
+        }
+        console.log(result.content.toString("utf-8"));
+      }
+    } 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 configure" 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."));
+      }
+      process.exit(1);
+    }
+  });
   return cmd;
 }
 
@@ -1363,7 +1347,7 @@ function formatSize(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 function cacheListCommand() {
-  const cmd = new commander.Command("list");
+  const cmd = new commander.Command("cache-list");
   cmd.description("List cache information").option("--json", "Output as JSON").action(async (options) => {
     try {
       const client = await getClient();
@@ -1402,8 +1386,8 @@ function cacheListCommand() {
       console.log(`Cache health: ${healthColor(`${healthPercent.toFixed(0)}% fresh`)}`);
       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(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.'));
     } catch (error) {
       console.error(chalk7__default.default.red("Error:"), error.message);
       process.exit(1);
@@ -1415,7 +1399,7 @@ 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();
@@ -1435,8 +1419,8 @@ function cacheClearCommand() {
         console.log(chalk7__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(chalk7__default.default.dim("  fractary-codex cache-clear --all"));
+        console.log(chalk7__default.default.dim('  fractary-codex cache-clear --pattern "codex://fractary/cli/*"'));
         return;
       }
       if (options.dryRun) {
@@ -1488,7 +1472,7 @@ function formatSize3(bytes) {
   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();
@@ -1509,7 +1493,7 @@ function cacheStatsCommand() {
       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`)}`);
       if (stats.expiredCount > 0) {
-        console.log(chalk7__default.default.dim('\nRun "fractary codex cache clear --pattern <pattern>" to clean up entries.'));
+        console.log(chalk7__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."));
@@ -1527,15 +1511,15 @@ init_cjs_shims();
 init_migrate_config();
 async function fileExists2(filePath) {
   try {
-    await fs__namespace.access(filePath);
+    await fs4__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");
+  const configPath = path2__namespace.join(process.cwd(), ".fractary", "config.yaml");
+  const legacyConfigPath = path2__namespace.join(process.cwd(), ".fractary", "plugins", "codex", "config.json");
   try {
     if (!await fileExists2(configPath)) {
       if (await fileExists2(legacyConfigPath)) {
@@ -1543,14 +1527,14 @@ async function checkConfiguration() {
           name: "Configuration",
           status: "warn",
           message: "Legacy JSON configuration detected",
-          details: 'Run "fractary codex migrate" to upgrade to YAML format'
+          details: "Migration from legacy JSON format may be required"
         };
       }
       return {
         name: "Configuration",
         status: "fail",
         message: "No configuration found",
-        details: 'Run "fractary codex init" to create configuration'
+        details: 'Run "fractary-codex configure" to create configuration'
       };
     }
     const config = await codex.readCodexConfig(configPath);
@@ -1642,7 +1626,7 @@ async function checkCache() {
   }
 }
 async function checkStorage() {
-  const configPath = path4__namespace.join(process.cwd(), ".fractary", "config.yaml");
+  const configPath = path2__namespace.join(process.cwd(), ".fractary", "config.yaml");
   try {
     const config = await codex.readCodexConfig(configPath);
     const providers = config.storage || [];
@@ -1706,8 +1690,8 @@ function formatSize4(bytes) {
   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 checks = [];
@@ -1750,8 +1734,7 @@ function healthCommand() {
       if (failed > 0 || 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(chalk7__default.default.dim("  fractary-codex cache-stats"));
       }
       if (failed > 0) {
         process.exit(1);
@@ -1764,17 +1747,6 @@ function healthCommand() {
   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();
@@ -1798,15 +1770,15 @@ function formatDuration(ms) {
 }
 function syncCommand() {
   const cmd = new commander.Command("sync");
-  cmd.description("Sync single project with codex repository").argument("[name]", "Project name (auto-detected if not provided)").option("--env <env>", "Target environment (dev/test/staging/prod)", "prod").option("--dry-run", "Show what would sync without executing").option("--direction <dir>", "Sync direction (to-codex/from-codex/bidirectional)", "bidirectional").option("--include <pattern>", "Include files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--exclude <pattern>", "Exclude files matching pattern (can be used multiple times)", (val, prev) => prev.concat([val]), []).option("--force", "Force sync without checking timestamps").option("--json", "Output as JSON").action(async (name, options) => {
+  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 = path2__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.log(chalk7__default.default.dim('Run "fractary-codex configure" first.'));
         process.exit(1);
       }
       const { createSyncManager, createLocalStorage, detectCurrentProject } = await import('@fractary/codex');
@@ -1837,7 +1809,7 @@ function syncCommand() {
       const syncManager = createSyncManager({
         localStorage,
         config: config.sync,
-        manifestPath: path4__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
+        manifestPath: path2__namespace.join(process.cwd(), ".fractary", ".codex-sync-manifest.json")
       });
       const defaultToCodexPatterns = [
         "docs/**/*.md",
@@ -1872,7 +1844,7 @@ function syncCommand() {
       }
       const targetFiles = await Promise.all(
         Array.from(matchedFilePaths).map(async (filePath) => {
-          const fullPath = path4__namespace.join(sourceDir, filePath);
+          const fullPath = path2__namespace.join(sourceDir, filePath);
           const stats = await import('fs/promises').then((fs8) => fs8.stat(fullPath));
           return {
             path: filePath,
@@ -1975,15 +1947,18 @@ function syncCommand() {
           syncOptions
         );
         plan.source = sourceDir;
-        plan.target = path4__namespace.join(codexRepoPath, "projects", projectName);
+        plan.target = path2__namespace.join(codexRepoPath, "projects", projectName);
       }
       if (plan.totalFiles === 0) {
         if (options.json) {
           console.log(JSON.stringify({
             project: projectName,
             organization: config.organization,
+            workId: options.workId || null,
             files: [],
-            synced: 0
+            synced: 0,
+            status: "success",
+            message: "No files to sync"
           }, null, 2));
         } else {
           console.log(chalk7__default.default.yellow("No files to sync."));
@@ -1998,6 +1973,7 @@ function syncCommand() {
           branch: targetBranch,
           direction,
           dryRun: options.dryRun || false,
+          workId: options.workId || null,
           plan: {
             totalFiles: plan.totalFiles,
             totalBytes: plan.totalBytes,
@@ -2012,12 +1988,24 @@ function syncCommand() {
           }))
         };
         if (options.dryRun) {
-          console.log(JSON.stringify(output, null, 2));
+          console.log(JSON.stringify({
+            ...output,
+            status: "success"
+          }, null, 2));
           return;
         }
         const result2 = await syncManager.executePlan(plan, syncOptions);
+        let status;
+        if (!result2.success && result2.synced === 0) {
+          status = "failure";
+        } else if (!result2.success || result2.failed > 0 || plan.conflicts.length > 0) {
+          status = "warning";
+        } else {
+          status = "success";
+        }
         console.log(JSON.stringify({
           ...output,
+          status,
           result: {
             success: result2.success,
             synced: result2.synced,
@@ -2151,361 +2139,20 @@ Total: ${plan.totalFiles} files (${formatBytes(plan.totalBytes)})`));
   });
   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.'));
-      }
-      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 = path2.dirname(__filename2);
+var packageJson = JSON.parse(fs.readFileSync(path2.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(configureCommand());
+  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() {