npm - @fractary/codex-cli - Versions diffs - 0.2.2 → 0.3.1 - Mend

@fractary/codex-cli 0.2.2 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/cli.cjs CHANGED Viewed

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