allagents 1.12.1-next.1 → 1.13.0-next.1

package/README.md

@@ -123,11 +123,18 @@ my-plugin/
 │       └── SKILL.md
 ├── agents/          # Agent definitions
 ├── commands/        # Slash commands (Claude, OpenCode)
-├── hooks/           # Lifecycle hooks (Claude, Factory, Copilot)
+├── hooks/           # Lifecycle hooks (Claude, Factory, Copilot, Codex)
+├── .codex-plugin/   # Codex plugin manifest and explicit hook paths
 ├── .github/         # Copilot/VSCode overrides
 └── .mcp.json        # MCP server configs
 ```
 
+For Codex project sync, AllAgents copies skills into `.codex/skills/`, merges
+plugin hooks into `.codex/hooks.json`, and preserves user-owned hooks already in
+that file. Codex plugins can declare hooks in `.codex-plugin/plugin.json` with a
+`hooks` path, path array, inline object, or inline object array; otherwise
+AllAgents falls back to `hooks/hooks.json`.
+
 ## Documentation
 
 Full documentation at [allagents.dev](https://allagents.dev):

package/dist/index.js

@@ -14729,7 +14729,7 @@ function parseGitHubUrl(url) {
   if (treeMatch) {
     const owner = treeMatch[1];
     const repo = treeMatch[2]?.replace(/\.git$/, "");
-    const afterTree = treeMatch[3];
+    const afterTree = decodeGitHubPath(treeMatch[3]);
     if (owner && repo && afterTree) {
       const parts = afterTree.split("/");
       if (parts.length === 1) {
@@ -14775,6 +14775,15 @@ function parseGitHubUrl(url) {
   }
   return null;
 }
+function decodeGitHubPath(path) {
+  if (!path)
+    return path;
+  try {
+    return decodeURIComponent(path);
+  } catch {
+    return path;
+  }
+}
 function normalizePluginPath(source, baseDir = process.cwd()) {
   if (isGitHubUrl(source)) {
     return source;
@@ -29354,6 +29363,9 @@ var init_sync_state = __esm(() => {
     version: exports_external.literal(1),
     lastSync: exports_external.string(),
     files: exports_external.record(ClientTypeSchema, exports_external.array(exports_external.string())),
+    codexHooks: exports_external.object({
+      hooks: exports_external.record(exports_external.string(), exports_external.array(exports_external.unknown()))
+    }).optional(),
     mcpServers: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional(),
     nativePlugins: exports_external.record(ClientTypeSchema, exports_external.array(exports_external.string())).optional(),
     vscodeWorkspaceHash: exports_external.string().optional(),
@@ -29422,6 +29434,7 @@ async function saveSyncState(workspacePath, data) {
     version: 1,
     lastSync: new Date().toISOString(),
     files: normalizedData.files,
+    ...normalizedData.codexHooks && { codexHooks: normalizedData.codexHooks },
     ...normalizedData.mcpServers && { mcpServers: normalizedData.mcpServers },
     ...normalizedData.nativePlugins && { nativePlugins: normalizedData.nativePlugins },
     ...normalizedData.vscodeWorkspaceHash && { vscodeWorkspaceHash: normalizedData.vscodeWorkspaceHash },
@@ -29455,6 +29468,7 @@ async function upsertSyncStateSource(workspacePath, key, source) {
   const sources = { ...existing?.sources ?? {}, [key]: source };
   await saveSyncState(workspacePath, {
     files: existing?.files ?? {},
+    ...existing?.codexHooks && { codexHooks: existing.codexHooks },
     ...existing?.mcpServers && {
       mcpServers: existing.mcpServers
     },
@@ -30208,9 +30222,301 @@ var init_codex_mcp = __esm(() => {
   init_vscode_mcp();
 });
 
+// src/core/codex-hooks.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync4, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { basename as basename8, dirname as dirname9, isAbsolute as isAbsolute4, join as join19, normalize as normalize4 } from "node:path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function hasHooks(file) {
+  if (!file)
+    return false;
+  return Object.values(file.hooks).some((groups) => groups.length > 0);
+}
+function orderedHooks(hooks) {
+  const ordered = {};
+  const remaining = new Set(Object.keys(hooks));
+  for (const event of CODEX_HOOK_EVENT_ORDER) {
+    if (remaining.has(event)) {
+      ordered[event] = hooks[event] ?? [];
+      remaining.delete(event);
+    }
+  }
+  for (const event of [...remaining].sort()) {
+    ordered[event] = hooks[event] ?? [];
+  }
+  return ordered;
+}
+function normalizeHooksObject(value, source, warnings, options2) {
+  if (!isRecord(value) || !isRecord(value.hooks)) {
+    warnings.push(`Codex hooks: ${source} must contain a hooks object`);
+    return null;
+  }
+  const hooks = {};
+  for (const [eventName, groups] of Object.entries(value.hooks)) {
+    if (options2.filterCodexEvents && !CODEX_HOOK_EVENTS.has(eventName)) {
+      warnings.push(`Codex hooks: unsupported event '${eventName}' in ${source} was skipped`);
+      continue;
+    }
+    if (!Array.isArray(groups)) {
+      warnings.push(`Codex hooks: event '${eventName}' in ${source} must be an array`);
+      if (options2.strictEventArrays) {
+        return null;
+      }
+      continue;
+    }
+    hooks[eventName] = cloneJson(groups);
+  }
+  return { hooks: orderedHooks(hooks) };
+}
+function parseHooksJson(content, source, warnings, options2) {
+  try {
+    return normalizeHooksObject(JSON.parse(content), source, warnings, options2);
+  } catch (error) {
+    warnings.push(`Codex hooks: failed to parse ${source}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+function readHooksJson(path, warnings, options2) {
+  try {
+    return parseHooksJson(readFileSync3(path, "utf-8"), path, warnings, options2);
+  } catch (error) {
+    warnings.push(`Codex hooks: failed to read ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+function resolveManifestPath(pluginPath, field, rawPath, warnings) {
+  if (!rawPath.startsWith("./")) {
+    warnings.push(`Codex hooks: ignoring ${field}; path must start with './'`);
+    return null;
+  }
+  const relativePath = rawPath.slice(2);
+  if (!relativePath) {
+    warnings.push(`Codex hooks: ignoring ${field}; path must not be './'`);
+    return null;
+  }
+  if (isAbsolute4(relativePath)) {
+    warnings.push(`Codex hooks: ignoring ${field}; path must stay within the plugin root`);
+    return null;
+  }
+  const normalized = normalize4(relativePath).replace(/\\/g, "/");
+  if (normalized === ".." || normalized.startsWith("../")) {
+    warnings.push(`Codex hooks: ignoring ${field}; path must not contain '..'`);
+    return null;
+  }
+  return join19(pluginPath, normalized);
+}
+function substitutePluginEnv(value, env2) {
+  if (typeof value === "string") {
+    return Object.entries(env2).reduce((current, [key, replacement]) => current.replaceAll(`\${${key}}`, replacement), value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => substitutePluginEnv(entry, env2));
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, substitutePluginEnv(entry, env2)]));
+  }
+  return value;
+}
+function withPluginEnv(hooksFile, pluginPath, pluginDataPath) {
+  const env2 = {
+    PLUGIN_ROOT: pluginPath,
+    CLAUDE_PLUGIN_ROOT: pluginPath,
+    PLUGIN_DATA: pluginDataPath,
+    CLAUDE_PLUGIN_DATA: pluginDataPath
+  };
+  return substitutePluginEnv(hooksFile, env2);
+}
+function pluginDataPath(workspacePath, plugin) {
+  const rawName = plugin.pluginName ?? basename8(plugin.resolved) ?? "plugin";
+  const safeName = rawName.replace(/[^a-zA-Z0-9_.-]/g, "-");
+  return join19(workspacePath, ".allagents", "plugin-data", safeName);
+}
+function readManifestHookDeclarations(pluginPath, manifestPath, warnings) {
+  let manifest;
+  try {
+    const parsed = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+    if (!isRecord(parsed)) {
+      warnings.push(`Codex hooks: ${manifestPath} must contain a JSON object`);
+      return null;
+    }
+    manifest = parsed;
+  } catch (error) {
+    warnings.push(`Codex hooks: failed to parse ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+  if (!("hooks" in manifest)) {
+    return null;
+  }
+  const hooks = manifest.hooks;
+  if (typeof hooks === "string") {
+    const path = resolveManifestPath(pluginPath, "hooks", hooks, warnings);
+    return path ? [{ path }] : null;
+  }
+  if (Array.isArray(hooks) && hooks.every((entry) => typeof entry === "string")) {
+    const paths = hooks.map((entry) => resolveManifestPath(pluginPath, "hooks", entry, warnings)).filter((entry) => entry !== null);
+    return paths.length > 0 ? paths.map((path) => ({ path })) : null;
+  }
+  if (Array.isArray(hooks) && hooks.every(isRecord)) {
+    const inline = hooks.map((entry, index) => normalizeHooksObject(entry, `${manifestPath}#hooks[${index}]`, warnings, {
+      filterCodexEvents: true
+    })).filter((entry) => entry !== null && hasHooks(entry));
+    return inline.length > 0 ? inline.map((entry) => ({ inline: entry })) : null;
+  }
+  if (isRecord(hooks)) {
+    const inline = normalizeHooksObject(hooks, `${manifestPath}#hooks`, warnings, {
+      filterCodexEvents: true
+    });
+    return inline && hasHooks(inline) ? [{ inline }] : null;
+  }
+  warnings.push(`Codex hooks: ignoring hooks in ${manifestPath}; expected a string, string array, object, or object array`);
+  return null;
+}
+function collectPluginCodexHooks(plugin, workspacePath, warnings) {
+  const pluginPath = plugin.resolved;
+  const manifestPath = join19(pluginPath, CODEX_PLUGIN_MANIFEST_RELATIVE_PATH);
+  const declarations = existsSync17(manifestPath) ? readManifestHookDeclarations(pluginPath, manifestPath, warnings) : null;
+  const effectiveDeclarations = declarations ?? (existsSync17(join19(pluginPath, DEFAULT_PLUGIN_HOOKS_RELATIVE_PATH)) ? [{ path: join19(pluginPath, DEFAULT_PLUGIN_HOOKS_RELATIVE_PATH) }] : []);
+  const dataPath = pluginDataPath(workspacePath, plugin);
+  const hooksFiles = [];
+  for (const declaration of effectiveDeclarations) {
+    const hooksFile = declaration.inline ?? (declaration.path ? readHooksJson(declaration.path, warnings, { filterCodexEvents: true }) : null);
+    if (hooksFile && hasHooks(hooksFile)) {
+      hooksFiles.push(withPluginEnv(hooksFile, pluginPath, dataPath));
+    }
+  }
+  return hooksFiles;
+}
+function mergeHooks(files) {
+  const merged = {};
+  for (const file of files) {
+    for (const [eventName, groups] of Object.entries(file.hooks)) {
+      if (groups.length === 0)
+        continue;
+      merged[eventName] = [...merged[eventName] ?? [], ...cloneJson(groups)];
+    }
+  }
+  return { hooks: orderedHooks(merged) };
+}
+function removeManagedHooks(existing, previousManaged) {
+  if (!hasHooks(previousManaged))
+    return cloneJson(existing);
+  const hooks = cloneJson(existing.hooks);
+  for (const [eventName, previousGroups] of Object.entries(previousManaged.hooks)) {
+    const groups = hooks[eventName];
+    if (!groups || groups.length === 0)
+      continue;
+    for (const previousGroup of previousGroups) {
+      const previousKey = JSON.stringify(previousGroup);
+      const index = groups.findIndex((group) => JSON.stringify(group) === previousKey);
+      if (index !== -1) {
+        groups.splice(index, 1);
+      }
+    }
+    if (groups.length === 0) {
+      delete hooks[eventName];
+    }
+  }
+  return { hooks: orderedHooks(hooks) };
+}
+function appendManagedHooks(base, currentManaged) {
+  const hooks = cloneJson(base.hooks);
+  for (const [eventName, groups] of Object.entries(currentManaged.hooks)) {
+    if (groups.length === 0)
+      continue;
+    hooks[eventName] = [...hooks[eventName] ?? [], ...cloneJson(groups)];
+  }
+  return { hooks: orderedHooks(hooks) };
+}
+function readExistingProjectHooks(hooksPath, warnings) {
+  if (!existsSync17(hooksPath)) {
+    return { hooks: { hooks: {} }, valid: true };
+  }
+  const parsed = readHooksJson(hooksPath, warnings, {
+    filterCodexEvents: false,
+    strictEventArrays: true
+  });
+  return parsed ? { hooks: parsed, valid: true } : { hooks: { hooks: {} }, valid: false };
+}
+function writeProjectHooks(hooksPath, hooksFile) {
+  mkdirSync4(dirname9(hooksPath), { recursive: true });
+  writeFileSync4(hooksPath, `${JSON.stringify(hooksFile, null, 2)}
+`, "utf-8");
+}
+function pluginTargetsCodex(plugin) {
+  return plugin.clients.includes("codex");
+}
+function syncCodexProjectHooks(validatedPlugins, workspacePath, previousManagedHooks, options2 = {}) {
+  const warnings = [];
+  const codexPlugins = validatedPlugins.filter((plugin) => plugin.success && pluginTargetsCodex(plugin));
+  const currentManagedHooks = mergeHooks(codexPlugins.flatMap((plugin) => collectPluginCodexHooks(plugin, workspacePath, warnings)));
+  const hasCurrentManagedHooks = hasHooks(currentManagedHooks);
+  const hadPreviousManagedHooks = hasHooks(previousManagedHooks);
+  if (!hasCurrentManagedHooks && !hadPreviousManagedHooks) {
+    return { copyResults: [], warnings };
+  }
+  const hooksPath = join19(workspacePath, CODEX_HOOKS_RELATIVE_PATH);
+  const { hooks: existingHooks, valid } = readExistingProjectHooks(hooksPath, warnings);
+  if (!valid) {
+    warnings.push(`Codex hooks: not updating ${CODEX_HOOKS_RELATIVE_PATH} because the existing file could not be parsed`);
+    return {
+      copyResults: [],
+      warnings,
+      ...hadPreviousManagedHooks && { managedHooks: previousManagedHooks }
+    };
+  }
+  const withoutPreviousManaged = removeManagedHooks(existingHooks, previousManagedHooks);
+  const withoutManagedDuplicates = removeManagedHooks(withoutPreviousManaged, currentManagedHooks);
+  const finalHooks = hasCurrentManagedHooks ? appendManagedHooks(withoutManagedDuplicates, currentManagedHooks) : withoutManagedDuplicates;
+  const hasFinalHooks = hasHooks(finalHooks);
+  if (!options2.dryRun) {
+    if (hasFinalHooks) {
+      writeProjectHooks(hooksPath, finalHooks);
+    } else if (existsSync17(hooksPath)) {
+      unlinkSync(hooksPath);
+    }
+    for (const plugin of codexPlugins) {
+      const dataPath = pluginDataPath(workspacePath, plugin);
+      if (hasCurrentManagedHooks) {
+        mkdirSync4(dataPath, { recursive: true });
+      }
+    }
+  }
+  return {
+    copyResults: [
+      {
+        source: "codex-plugin-hooks",
+        destination: hooksPath,
+        action: "generated"
+      }
+    ],
+    warnings,
+    ...hasCurrentManagedHooks && { managedHooks: currentManagedHooks }
+  };
+}
+var CODEX_HOOKS_RELATIVE_PATH = ".codex/hooks.json", CODEX_PLUGIN_MANIFEST_RELATIVE_PATH = ".codex-plugin/plugin.json", DEFAULT_PLUGIN_HOOKS_RELATIVE_PATH = "hooks/hooks.json", CODEX_HOOK_EVENT_ORDER, CODEX_HOOK_EVENTS;
+var init_codex_hooks = __esm(() => {
+  CODEX_HOOK_EVENT_ORDER = [
+    "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SessionStart",
+    "UserPromptSubmit",
+    "SubagentStart",
+    "SubagentStop",
+    "Stop"
+  ];
+  CODEX_HOOK_EVENTS = new Set(CODEX_HOOK_EVENT_ORDER);
+});
+
 // src/core/claude-mcp.ts
-import { existsSync as existsSync17, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 function deepEqual2(a, b) {
   if (a === b)
     return true;
@@ -30277,9 +30583,9 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingConfig = {};
-  if (existsSync17(configPath)) {
+  if (existsSync18(configPath)) {
     try {
-      const content = readFileSync3(configPath, "utf-8");
+      const content = readFileSync4(configPath, "utf-8");
       existingConfig = import_json52.default.parse(content);
     } catch {
       result.warnings.push(`Could not parse existing ${configPath}, starting fresh`);
@@ -30327,11 +30633,11 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
   const hasChanges = result.added > 0 || result.overwritten > 0 || result.removed > 0;
   if (hasChanges && !dryRun) {
     existingConfig.mcpServers = existingServers;
-    const dir = dirname9(configPath);
-    if (!existsSync17(dir)) {
-      mkdirSync4(dir, { recursive: true });
+    const dir = dirname10(configPath);
+    if (!existsSync18(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
-    writeFileSync4(configPath, `${JSON.stringify(existingConfig, null, 2)}
+    writeFileSync5(configPath, `${JSON.stringify(existingConfig, null, 2)}
 `, "utf-8");
     result.configPath = configPath;
   }
@@ -30345,11 +30651,11 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
     }
     if (result.removed > 0 && !dryRun) {
       existingConfig.mcpServers = existingServers;
-      const dir = dirname9(configPath);
-      if (!existsSync17(dir)) {
-        mkdirSync4(dir, { recursive: true });
+      const dir = dirname10(configPath);
+      if (!existsSync18(dir)) {
+        mkdirSync5(dir, { recursive: true });
       }
-      writeFileSync4(configPath, `${JSON.stringify(existingConfig, null, 2)}
+      writeFileSync5(configPath, `${JSON.stringify(existingConfig, null, 2)}
 `, "utf-8");
       result.configPath = configPath;
     }
@@ -30445,41 +30751,41 @@ var init_claude_mcp = __esm(() => {
 });
 
 // src/core/copilot-mcp.ts
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function getCopilotMcpConfigPath() {
-  return join19(getHomeDir(), ".copilot", "mcp-config.json");
+  return join20(getHomeDir(), ".copilot", "mcp-config.json");
 }
 var init_copilot_mcp = __esm(() => {
   init_constants();
 });
 
 // src/core/mcp-sync.ts
-import { existsSync as existsSync18 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { join as join21 } from "node:path";
 function buildSyncSpecs(workspacePath) {
   return [
     {
       client: "vscode",
       scope: "vscode",
-      configPath: join20(workspacePath, ".vscode", "mcp.json"),
+      configPath: join21(workspacePath, ".vscode", "mcp.json"),
       syncFn: syncVscodeMcpConfig
     },
     {
       client: "claude",
       scope: "claude",
-      configPath: join20(workspacePath, ".mcp.json"),
+      configPath: join21(workspacePath, ".mcp.json"),
       syncFn: syncClaudeMcpConfig
     },
     {
       client: "codex",
       scope: "codex",
-      configPath: join20(workspacePath, ".codex", "config.toml"),
+      configPath: join21(workspacePath, ".codex", "config.toml"),
       syncFn: syncCodexProjectMcpConfig
     },
     {
       client: "copilot",
       scope: "copilot",
-      configPath: join20(workspacePath, ".copilot", "mcp-config.json"),
+      configPath: join21(workspacePath, ".copilot", "mcp-config.json"),
       syncFn: syncClaudeMcpConfig
     }
   ];
@@ -30534,8 +30840,8 @@ function syncMcpServers(workspacePath, validPlugins, config, previousState, sync
 async function syncMcpOnly(workspacePath = process.cwd(), options2 = {}) {
   const { offline = false, dryRun = false } = options2;
   await migrateWorkspaceSkillsV1toV2(workspacePath);
-  const configPath = join20(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync18(configPath)) {
+  const configPath = join21(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync19(configPath)) {
     return {
       success: false,
       mcpResults: {},
@@ -30909,9 +31215,9 @@ function padStart2(str3, len) {
 }
 
 // src/core/managed-repos.ts
-import { existsSync as existsSync19 } from "node:fs";
+import { existsSync as existsSync20 } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve11 } from "node:path";
+import { dirname as dirname11, resolve as resolve11 } from "node:path";
 function expandHome(p) {
   if (p.startsWith("~/") || p === "~") {
     return p.replace("~", getHomeDir());
@@ -30954,7 +31260,7 @@ function buildCloneUrl(source, repo) {
   }
 }
 async function cloneRepo(url, dest, branch) {
-  await mkdir8(dirname10(dest), { recursive: true });
+  await mkdir8(dirname11(dest), { recursive: true });
   const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS2 } }).env(createGitEnv());
   const cloneOptions = branch ? ["--branch", branch] : [];
   await git.clone(url, dest, cloneOptions);
@@ -30993,7 +31299,7 @@ async function processManagedRepos(repositories, workspacePath, options2 = {}) {
     }
     const expandedPath = expandHome(repo.path);
     const absolutePath = resolve11(workspacePath, expandedPath);
-    if (!existsSync19(absolutePath)) {
+    if (!existsSync20(absolutePath)) {
       if (!shouldClone(repo.managed)) {
         results.push({ path: repo.path, repo: repo.repo, action: "skipped" });
         continue;
@@ -31045,9 +31351,9 @@ var init_managed_repos = __esm(() => {
 });
 
 // src/core/sync.ts
-import { existsSync as existsSync20, readFileSync as readFileSync4, writeFileSync as writeFileSync5, lstatSync as lstatSync2 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync5, writeFileSync as writeFileSync6, lstatSync as lstatSync2 } from "node:fs";
 import { rm as rm4, unlink as unlink2, rmdir, copyFile } from "node:fs/promises";
-import { join as join21, resolve as resolve12, dirname as dirname11, relative as relative6 } from "node:path";
+import { join as join22, resolve as resolve12, dirname as dirname12, relative as relative6 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -31210,7 +31516,7 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
-      const fullPath = join21(workspacePath, filePath);
+      const fullPath = join22(workspacePath, filePath);
       const cleanPath = fullPath.replace(/\/$/, "");
       let stats;
       try {
@@ -31237,16 +31543,16 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
   return result;
 }
 async function cleanupEmptyParents(workspacePath, filePath) {
-  let parentPath = dirname11(filePath);
+  let parentPath = dirname12(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
-    const fullParentPath = join21(workspacePath, parentPath);
-    if (!existsSync20(fullParentPath)) {
-      parentPath = dirname11(parentPath);
+    const fullParentPath = join22(workspacePath, parentPath);
+    if (!existsSync21(fullParentPath)) {
+      parentPath = dirname12(parentPath);
       continue;
     }
     try {
       await rmdir(fullParentPath);
-      parentPath = dirname11(parentPath);
+      parentPath = dirname12(parentPath);
     } catch {
       break;
     }
@@ -31325,8 +31631,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
         continue;
       }
-      const fullPath = join21(defaultSourcePath, file);
-      if (!existsSync20(fullPath)) {
+      const fullPath = join22(defaultSourcePath, file);
+      if (!existsSync21(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -31344,8 +31650,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           errors2.push(`GitHub cache not found for ${cacheKey}`);
           continue;
         }
-        const fullPath = join21(cachePath, parsed.filePath);
-        if (!existsSync20(fullPath)) {
+        const fullPath = join22(cachePath, parsed.filePath);
+        if (!existsSync21(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -31355,11 +31661,11 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         } else if (file.source.startsWith("../")) {
           fullPath = resolve12(file.source);
         } else if (defaultSourcePath) {
-          fullPath = join21(defaultSourcePath, file.source);
+          fullPath = join22(defaultSourcePath, file.source);
         } else {
           fullPath = resolve12(file.source);
         }
-        if (!existsSync20(fullPath)) {
+        if (!existsSync21(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -31368,8 +31674,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file.dest}' - no workspace.source configured and no explicit source provided`);
         continue;
       }
-      const fullPath = join21(defaultSourcePath, file.dest ?? "");
-      if (!existsSync20(fullPath)) {
+      const fullPath = join22(defaultSourcePath, file.dest ?? "");
+      if (!existsSync21(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -31517,7 +31823,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
         ...fetchResult.error && { error: fetchResult.error }
       };
     }
-    const resolvedPath2 = parsed?.subpath ? join21(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
+    const resolvedPath2 = parsed?.subpath ? join22(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
     return {
       plugin: pluginSource,
       resolved: resolvedPath2,
@@ -31527,7 +31833,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
     };
   }
   const resolvedPath = resolve12(workspacePath, pluginSource);
-  if (!existsSync20(resolvedPath)) {
+  if (!existsSync21(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -31700,12 +32006,12 @@ function buildPluginSkillNameMaps(allSkills) {
   return pluginMaps;
 }
 function generateVscodeWorkspaceFile(workspacePath, config) {
-  const configDir = join21(workspacePath, CONFIG_DIR);
-  const templatePath = join21(configDir, VSCODE_TEMPLATE_FILE);
+  const configDir = join22(workspacePath, CONFIG_DIR);
+  const templatePath = join22(configDir, VSCODE_TEMPLATE_FILE);
   let template;
-  if (existsSync20(templatePath)) {
+  if (existsSync21(templatePath)) {
     try {
-      template = import_json53.default.parse(readFileSync4(templatePath, "utf-8"));
+      template = import_json53.default.parse(readFileSync5(templatePath, "utf-8"));
     } catch (error) {
       throw new Error(`Failed to parse ${templatePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -31718,7 +32024,7 @@ function generateVscodeWorkspaceFile(workspacePath, config) {
   const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
   const contentStr = `${JSON.stringify(content, null, "\t")}
 `;
-  writeFileSync5(outputPath, contentStr, "utf-8");
+  writeFileSync6(outputPath, contentStr, "utf-8");
   return contentStr;
 }
 function failedSyncResult(error, overrides) {
@@ -31761,6 +32067,9 @@ function countCopyResults(pluginResults, workspaceFileResults) {
       case "copied":
         totalCopied++;
         break;
+      case "generated":
+        totalGenerated++;
+        break;
       case "failed":
         totalFailed++;
         break;
@@ -31855,8 +32164,8 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   let updatedConfig = config;
   if (previousState?.vscodeWorkspaceHash && previousState?.vscodeWorkspaceRepos) {
     const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
-    if (existsSync20(outputPath)) {
-      const existingContent = readFileSync4(outputPath, "utf-8");
+    if (existsSync21(outputPath)) {
+      const existingContent = readFileSync5(outputPath, "utf-8");
       const currentHash = computeWorkspaceHash(existingContent);
       if (currentHash !== previousState.vscodeWorkspaceHash) {
         try {
@@ -31946,6 +32255,7 @@ async function persistSyncState(workspacePath, pluginResults, workspaceFileResul
   }
   await saveSyncState(workspacePath, {
     files: syncedFiles,
+    ...extra?.codexHooks && { codexHooks: extra.codexHooks },
     ...Object.keys(nativePluginsState).length > 0 && {
       nativePlugins: nativePluginsState
     },
@@ -31970,9 +32280,9 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
     skipManaged = false
   } = options2;
   const sw = new Stopwatch;
-  const configDir = join21(workspacePath, CONFIG_DIR);
-  const configPath = join21(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync20(configPath)) {
+  const configDir = join22(workspacePath, CONFIG_DIR);
+  const configPath = join22(configDir, WORKSPACE_CONFIG_FILE);
+  if (!existsSync21(configPath)) {
     return failedSyncResult(`${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
   Run 'allagents workspace init <path>' to create a new workspace`);
   }
@@ -32060,7 +32370,11 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     return { ...result, scope: "project" };
   })), `${validPlugins.length} plugin(s)`);
   const nativeResult = await sw.measure("native-plugin-sync", () => syncNativePlugins(validPlugins, previousState, "project", workspacePath, dryRun, warnings, messages));
-  let workspaceFileResults = [];
+  const codexHookSync = await sw.measure("codex-hooks-sync", async () => syncCodexProjectHooks(validPlugins, workspacePath, previousState?.codexHooks, {
+    dryRun
+  }));
+  warnings.push(...codexHookSync.warnings);
+  const workspaceFileResults = [...codexHookSync.copyResults];
   let writtenSkillsIndexFiles = [];
   const skipWorkspaceFiles = !!config.workspace?.source && !validatedWorkspaceSource;
   if (config.workspace && !skipWorkspaceFiles) {
@@ -32069,8 +32383,8 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     const filesToCopy = [...config.workspace.files];
     if (hasRepositories && sourcePath) {
       for (const agentFile of AGENT_FILES) {
-        const agentPath = join21(sourcePath, agentFile);
-        if (existsSync20(agentPath) && !filesToCopy.includes(agentFile)) {
+        const agentPath = join22(sourcePath, agentFile);
+        if (existsSync21(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -32103,17 +32417,17 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
       }
       cleanupSkillsIndex(workspacePath, writtenSkillsIndexFiles);
     }
-    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, {
+    workspaceFileResults.push(...await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, {
       dryRun,
       githubCache,
       repositories: config.repositories,
       skillsIndexRefs
-    });
+    }));
     if (hasRepositories && !dryRun && syncClients.includes("claude") && sourcePath) {
-      const claudePath = join21(workspacePath, "CLAUDE.md");
-      const agentsPath = join21(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync20(join21(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync20(agentsPath) && !existsSync20(claudePath)) {
+      const claudePath = join22(workspacePath, "CLAUDE.md");
+      const agentsPath = join22(workspacePath, "AGENTS.md");
+      const claudeExistsInSource = existsSync21(join22(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync21(agentsPath) && !existsSync21(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -32152,6 +32466,9 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     const sources = await buildSourcesProvenance(validPlugins, config.plugins);
     await sw.measure("persist-state", () => persistSyncState(workspacePath, pluginResults, workspaceFileResults, syncClients, nativePluginsByClient, nativeResult, {
       ...vscodeState && { vscodeState },
+      ...codexHookSync.managedHooks && {
+        codexHooks: codexHookSync.managedHooks
+      },
       ...Object.keys(mcpResults).length > 0 && {
         mcpTrackedServers: Object.fromEntries(Object.entries(mcpResults).map(([scope, r]) => [
           scope,
@@ -32197,7 +32514,7 @@ async function seedFetchCacheFromMarketplaces(results) {
 }
 function readGitBranch(repoPath) {
   try {
-    const head = readFileSync4(join21(repoPath, ".git", "HEAD"), "utf-8").trim();
+    const head = readFileSync5(join22(repoPath, ".git", "HEAD"), "utf-8").trim();
     const prefix = "ref: refs/heads/";
     return head.startsWith(prefix) ? head.slice(prefix.length) : null;
   } catch {
@@ -32396,6 +32713,7 @@ var init_sync = __esm(() => {
   init_workspace_modify();
   init_vscode_mcp();
   init_codex_mcp();
+  init_codex_hooks();
   init_claude_mcp();
   init_copilot_mcp();
   init_mcp_sync();
@@ -32405,12 +32723,12 @@ var init_sync = __esm(() => {
 });
 
 // src/core/github-fetch.ts
-import { existsSync as existsSync21, readFileSync as readFileSync5 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync6 } from "node:fs";
+import { join as join23 } from "node:path";
 function readFileFromClone(tempDir, filePath) {
-  const fullPath = join22(tempDir, filePath);
-  if (existsSync21(fullPath)) {
-    return readFileSync5(fullPath, "utf-8");
+  const fullPath = join23(tempDir, filePath);
+  if (existsSync22(fullPath)) {
+    return readFileSync6(fullPath, "utf-8");
   }
   return null;
 }
@@ -32509,14 +32827,14 @@ var init_github_fetch = __esm(() => {
 
 // src/core/workspace.ts
 import { cp as cp2, mkdir as mkdir9, readFile as readFile13, writeFile as writeFile9, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join23, resolve as resolve13, dirname as dirname12, relative as relative7, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join24, resolve as resolve13, dirname as dirname13, relative as relative7, sep as sep2, isAbsolute as isAbsolute5 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function initWorkspace(targetPath = ".", options2 = {}) {
   const absoluteTarget = resolve13(targetPath);
-  const configDir = join23(absoluteTarget, CONFIG_DIR);
-  const configPath = join23(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync22(configPath)) {
+  const configDir = join24(absoluteTarget, CONFIG_DIR);
+  const configPath = join24(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync23(configPath)) {
     if (options2.force) {
       await unlink3(configPath);
     } else {
@@ -32525,9 +32843,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     }
   }
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentFileDir = dirname12(currentFilePath);
+  const currentFileDir = dirname13(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
-  const defaultTemplatePath = isProduction ? join23(currentFileDir, "templates", "default") : join23(currentFileDir, "..", "templates", "default");
+  const defaultTemplatePath = isProduction ? join24(currentFileDir, "templates", "default") : join24(currentFileDir, "..", "templates", "default");
   let githubTempDir;
   let parsedFromUrl;
   let githubBasePath = "";
@@ -32556,7 +32874,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         const workspace = parsed2?.workspace;
         if (workspace?.source) {
           const source = workspace.source;
-          if (!isGitHubUrl(source) && !isAbsolute4(source)) {
+          if (!isGitHubUrl(source) && !isAbsolute5(source)) {
             if (parsedFromUrl) {
               const sourcePath = source === "." ? githubBasePath : githubBasePath ? `${githubBasePath}/${source}` : source;
               workspace.source = `https://github.com/${parsedFromUrl.owner}/${parsedFromUrl.repo}/tree/${githubBranch}/${sourcePath}`;
@@ -32567,19 +32885,19 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
         const fromPath = resolve13(options2.from);
-        if (!existsSync22(fromPath)) {
+        if (!existsSync23(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
         const { stat: stat2 } = await import("node:fs/promises");
         const fromStat = await stat2(fromPath);
         let sourceYamlPath;
         if (fromStat.isDirectory()) {
-          const nestedPath = join23(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-          const rootPath = join23(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync22(nestedPath)) {
+          const nestedPath = join24(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          const rootPath = join24(fromPath, WORKSPACE_CONFIG_FILE);
+          if (existsSync23(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync22(rootPath)) {
+          } else if (existsSync23(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -32588,9 +32906,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else {
           sourceYamlPath = fromPath;
-          const parentDir = dirname12(fromPath);
+          const parentDir = dirname13(fromPath);
           if (parentDir.endsWith(CONFIG_DIR)) {
-            sourceDir = dirname12(parentDir);
+            sourceDir = dirname13(parentDir);
           } else {
             sourceDir = parentDir;
           }
@@ -32601,7 +32919,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           const workspace = parsed2?.workspace;
           if (workspace?.source) {
             const source = workspace.source;
-            if (!isGitHubUrl(source) && !isAbsolute4(source)) {
+            if (!isGitHubUrl(source) && !isAbsolute5(source)) {
               workspace.source = resolve13(sourceDir, source);
               workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
             }
@@ -32610,8 +32928,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
       }
     } else {
-      const defaultYamlPath = join23(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync22(defaultYamlPath)) {
+      const defaultYamlPath = join24(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      if (!existsSync23(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
       workspaceYamlContent = await readFile13(defaultYamlPath, "utf-8");
@@ -32627,8 +32945,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     const clientNames = getClientTypes(clients);
     const VSCODE_TEMPLATE_FILE2 = "template.code-workspace";
     if (clientNames.includes("vscode") && options2.from) {
-      const targetTemplatePath = join23(configDir, VSCODE_TEMPLATE_FILE2);
-      if (!existsSync22(targetTemplatePath)) {
+      const targetTemplatePath = join24(configDir, VSCODE_TEMPLATE_FILE2);
+      if (!existsSync23(targetTemplatePath)) {
         if (isGitHubUrl(options2.from) && githubTempDir) {
           if (parsedFromUrl) {
             const templatePath = githubBasePath ? `${githubBasePath}/${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}` : `${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}`;
@@ -32638,8 +32956,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             }
           }
         } else if (sourceDir) {
-          const sourceTemplatePath = join23(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
-          if (existsSync22(sourceTemplatePath)) {
+          const sourceTemplatePath = join24(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
+          if (existsSync23(sourceTemplatePath)) {
             await copyFile2(sourceTemplatePath, targetTemplatePath);
           }
         }
@@ -32652,8 +32970,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       if (options2.from && isGitHubUrl(options2.from) && githubTempDir) {
         if (parsedFromUrl) {
           for (const agentFile of AGENT_FILES) {
-            const targetFilePath = join23(absoluteTarget, agentFile);
-            if (existsSync22(targetFilePath)) {
+            const targetFilePath = join24(absoluteTarget, agentFile);
+            if (existsSync23(targetFilePath)) {
               copiedAgentFiles.push(agentFile);
               continue;
             }
@@ -32668,13 +32986,13 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       } else {
         const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
         for (const agentFile of AGENT_FILES) {
-          const targetFilePath = join23(absoluteTarget, agentFile);
-          if (existsSync22(targetFilePath)) {
+          const targetFilePath = join24(absoluteTarget, agentFile);
+          if (existsSync23(targetFilePath)) {
             copiedAgentFiles.push(agentFile);
             continue;
           }
-          const sourcePath = join23(effectiveSourceDir, agentFile);
-          if (existsSync22(sourcePath)) {
+          const sourcePath = join24(effectiveSourceDir, agentFile);
+          if (existsSync23(sourcePath)) {
             const content = await readFile13(sourcePath, "utf-8");
             await writeFile9(targetFilePath, content, "utf-8");
             copiedAgentFiles.push(agentFile);
@@ -32682,16 +33000,16 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
       }
       if (copiedAgentFiles.length === 0) {
-        await ensureWorkspaceRules(join23(absoluteTarget, "AGENTS.md"), repositories);
+        await ensureWorkspaceRules(join24(absoluteTarget, "AGENTS.md"), repositories);
         copiedAgentFiles.push("AGENTS.md");
       } else {
         for (const agentFile of copiedAgentFiles) {
-          await ensureWorkspaceRules(join23(absoluteTarget, agentFile), repositories);
+          await ensureWorkspaceRules(join24(absoluteTarget, agentFile), repositories);
         }
       }
       if (clientNames.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
-        const agentsPath = join23(absoluteTarget, "AGENTS.md");
-        const claudePath = join23(absoluteTarget, "CLAUDE.md");
+        const agentsPath = join24(absoluteTarget, "AGENTS.md");
+        const claudePath = join24(absoluteTarget, "CLAUDE.md");
         await copyFile2(agentsPath, claudePath);
       }
     }
@@ -32736,14 +33054,14 @@ Next steps:`);
 async function seedCacheFromClone(tempDir, owner, repo, branch) {
   const cachePaths = [
     getPluginCachePath(owner, repo, branch),
-    join23(getMarketplacesDir(), repo)
+    join24(getMarketplacesDir(), repo)
   ];
   for (const cachePath of cachePaths) {
-    if (existsSync22(cachePath))
+    if (existsSync23(cachePath))
       continue;
     try {
-      const parentDir = dirname12(cachePath);
-      if (!existsSync22(parentDir)) {
+      const parentDir = dirname13(cachePath);
+      if (!existsSync23(parentDir)) {
         await mkdir9(parentDir, { recursive: true });
       }
       await cp2(tempDir, cachePath, { recursive: true });
@@ -34904,17 +35222,17 @@ function buildSearchQueries(query, owner) {
   const trimmed2 = query.trim();
   const pathTerm = trimmed2.replace(/ /g, "-");
   const userClause = owner ? `user:${owner}` : "";
-  const join25 = (...parts) => parts.filter(Boolean).join(" ");
+  const join26 = (...parts) => parts.filter(Boolean).join(" ");
   const queries = [
-    { priority: 1, label: "path", q: join25("filename:SKILL.md", `path:${pathTerm}`, userClause) }
+    { priority: 1, label: "path", q: join26("filename:SKILL.md", `path:${pathTerm}`, userClause) }
   ];
   if (pathTerm !== trimmed2) {
-    queries.push({ priority: 2, label: "hyphen", q: join25("filename:SKILL.md", pathTerm, userClause) });
+    queries.push({ priority: 2, label: "hyphen", q: join26("filename:SKILL.md", pathTerm, userClause) });
   }
   if (!owner && couldBeOwner(trimmed2)) {
     queries.push({ priority: 3, label: "owner", q: `filename:SKILL.md user:${trimmed2}` });
   }
-  queries.push({ priority: 4, label: "primary", q: join25("filename:SKILL.md", trimmed2, userClause) });
+  queries.push({ priority: 4, label: "primary", q: join26("filename:SKILL.md", trimmed2, userClause) });
   return queries;
 }
 function classifyApiError(status, body) {
@@ -37433,8 +37751,8 @@ var require_resolve = __commonJS((exports) => {
     }
     return count;
   }
-  function getFullPath(resolver, id = "", normalize4) {
-    if (normalize4 !== false)
+  function getFullPath(resolver, id = "", normalize5) {
+    if (normalize5 !== false)
       id = normalizeId(id);
     const p = resolver.parse(id);
     return _getFullPath(resolver, p);
@@ -38721,7 +39039,7 @@ var require_schemes = __commonJS((exports, module) => {
 var require_fast_uri = __commonJS((exports, module) => {
   var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils7();
   var { SCHEMES, getSchemeHandler } = require_schemes();
-  function normalize4(uri, options2) {
+  function normalize5(uri, options2) {
     if (typeof uri === "string") {
       uri = serialize(parse6(uri, options2), options2);
     } else if (typeof uri === "object") {
@@ -38956,7 +39274,7 @@ var require_fast_uri = __commonJS((exports, module) => {
   }
   var fastUri = {
     SCHEMES,
-    normalize: normalize4,
+    normalize: normalize5,
     resolve: resolve15,
     resolveComponent,
     equal,
@@ -42256,7 +42574,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.12.1-next.1",
+    version: "1.13.0-next.1",
     packageManager: "bun@1.3.12",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
@@ -42341,10 +42659,10 @@ var init_package = __esm(() => {
 
 // src/cli/update-check.ts
 import { readFile as readFile18 } from "node:fs/promises";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 async function getCachedUpdateInfo(path3) {
-  const filePath = path3 ?? join29(getHomeDir(), CONFIG_DIR, CACHE_FILE);
+  const filePath = path3 ?? join30(getHomeDir(), CONFIG_DIR, CACHE_FILE);
   try {
     const raw = await readFile18(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -42382,8 +42700,8 @@ function buildNotice(currentVersion, latestVersion) {
 Run \`allagents self update\` to upgrade.`);
 }
 function backgroundUpdateCheck() {
-  const dir = join29(getHomeDir(), CONFIG_DIR);
-  const filePath = join29(dir, CACHE_FILE);
+  const dir = join30(getHomeDir(), CONFIG_DIR);
+  const filePath = join30(dir, CACHE_FILE);
   const script = `
     const https = require('https');
     const fs = require('fs');
@@ -42470,15 +42788,15 @@ class TuiCache {
 }
 
 // src/cli/tui/context.ts
-import { existsSync as existsSync27 } from "node:fs";
-import { join as join30 } from "node:path";
+import { existsSync as existsSync28 } from "node:fs";
+import { join as join31 } from "node:path";
 async function getTuiContext(cwd = process.cwd(), cache2) {
   const cachedContext = cache2?.getContext();
   if (cachedContext) {
     return cachedContext;
   }
-  const configPath = join30(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  const hasWorkspace = existsSync27(configPath) && !isUserConfigPath(cwd);
+  const configPath = join31(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  const hasWorkspace = existsSync28(configPath) && !isUserConfigPath(cwd);
   let projectPluginCount = 0;
   if (hasWorkspace) {
     try {
@@ -43938,8 +44256,8 @@ function conciseSubcommands(config) {
 
 // src/cli/commands/workspace.ts
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync23 } from "node:fs";
-import { join as join24, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync24 } from "node:fs";
+import { join as join25, resolve as resolve14 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -44406,8 +44724,8 @@ var syncCmd = import_cmd_ts2.command({
 `);
       }
       const userConfigExists = !!await getUserWorkspaceConfig();
-      const projectConfigPath = join24(process.cwd(), ".allagents", "workspace.yaml");
-      const projectConfigExists = existsSync23(projectConfigPath);
+      const projectConfigPath = join25(process.cwd(), ".allagents", "workspace.yaml");
+      const projectConfigExists = existsSync24(projectConfigPath);
       if (!userConfigExists && !projectConfigExists) {
         await ensureUserWorkspace();
         if (isJsonMode()) {
@@ -45138,9 +45456,9 @@ init_plugin_path();
 init_skill();
 init_format_sync();
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync24 } from "node:fs";
+import { existsSync as existsSync25 } from "node:fs";
 import { readFile as readFile14 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 
 // src/cli/metadata/plugin-skills.ts
 var skillsListMeta = {
@@ -45331,7 +45649,7 @@ var skillsAddMeta = {
 // src/cli/commands/plugin-skills.ts
 init_skill_removal();
 function hasProjectConfig(dir) {
-  return existsSync24(join25(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
+  return existsSync25(join26(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
 }
 function resolveScope(cwd) {
   if (isUserConfigPath(cwd))
@@ -45365,7 +45683,7 @@ function resolveFetchedSourcePath(source, cachePath) {
   if (!isGitHubUrl(source))
     return cachePath;
   const parsed = parseGitHubUrl(source);
-  return parsed?.subpath ? join25(cachePath, parsed.subpath) : cachePath;
+  return parsed?.subpath ? join26(cachePath, parsed.subpath) : cachePath;
 }
 function extractInlineRef(spec) {
   const slashIdx = spec.indexOf("/");
@@ -45401,7 +45719,7 @@ async function resolveSkillNameFromRepo(url, parsed, fallbackName, fetchFn = fet
   if (!fetchResult.success)
     return fallbackName;
   try {
-    const skillMd = await readFile14(join25(fetchResult.cachePath, "SKILL.md"), "utf-8");
+    const skillMd = await readFile14(join26(fetchResult.cachePath, "SKILL.md"), "utf-8");
     const metadata = parseSkillMetadata(skillMd);
     return metadata?.name ?? fallbackName;
   } catch {
@@ -45917,7 +46235,7 @@ async function discoverSkillsWithMetadata(pluginPath, pluginName) {
   const entries = await discoverSkillEntries(pluginPath);
   const results = [];
   for (const entry of entries) {
-    const skillMdPath = join25(entry.skillPath, "SKILL.md");
+    const skillMdPath = join26(entry.skillPath, "SKILL.md");
     let description = "";
     try {
       const content = await readFile14(skillMdPath, "utf-8");
@@ -45952,7 +46270,7 @@ async function discoverSkillsFromSource(from) {
       if (typeof plugin.source === "object")
         continue;
       const resolved = resolvePluginSourcePath(plugin.source, sourcePath);
-      if (!existsSync24(resolved))
+      if (!existsSync25(resolved))
         continue;
       const skills2 = await discoverSkillsWithMetadata(resolved, plugin.name);
       all.push(...skills2);
@@ -47034,8 +47352,8 @@ init_workspace_config();
 init_constants();
 init_js_yaml();
 import { readFile as readFile15 } from "node:fs/promises";
-import { existsSync as existsSync25 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { join as join27 } from "node:path";
 async function runSyncAndPrint(options2) {
   if (!isJsonMode()) {
     console.log(`
@@ -47280,7 +47598,7 @@ var marketplaceAddCmd = import_cmd_ts4.command({
         process.exit(1);
       }
       if (effectiveScope === "project") {
-        if (!existsSync25(join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
+        if (!existsSync26(join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
           const msg = 'No workspace found in current directory. Run "allagents workspace init" first.';
           if (isJsonMode()) {
             jsonOutput({ success: false, command: "plugin marketplace add", error: msg });
@@ -47587,7 +47905,7 @@ var pluginListCmd = import_cmd_ts4.command({
       };
       const pluginClients = new Map;
       async function loadConfigClients(configPath, scope) {
-        if (!existsSync25(configPath))
+        if (!existsSync26(configPath))
           return;
         try {
           const content = await readFile15(configPath, "utf-8");
@@ -47602,8 +47920,8 @@ var pluginListCmd = import_cmd_ts4.command({
           }
         } catch {}
       }
-      const userConfigPath = join26(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
-      const projectConfigPath = join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      const userConfigPath = join27(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
+      const projectConfigPath = join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
       const cwdIsHome = isUserConfigPath(process.cwd());
       await loadConfigClients(userConfigPath, "user");
       if (!cwdIsHome) {
@@ -47766,7 +48084,7 @@ var pluginInstallCmd = import_cmd_ts4.command({
       const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
       if (isUser) {
         const userConfigPath = getUserWorkspaceConfigPath();
-        if (!existsSync25(userConfigPath)) {
+        if (!existsSync26(userConfigPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -47778,8 +48096,8 @@ var pluginInstallCmd = import_cmd_ts4.command({
           await ensureUserWorkspace(clients);
         }
       } else {
-        const configPath = join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-        if (!existsSync25(configPath)) {
+        const configPath = join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+        if (!existsSync26(configPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -48056,13 +48374,13 @@ var pluginUpdateCmd = import_cmd_ts4.command({
         }
       }
       if (updateProject && !isUserConfigPath(process.cwd())) {
-        const { existsSync: existsSync26 } = await import("node:fs");
+        const { existsSync: existsSync27 } = await import("node:fs");
         const { readFile: readFile16 } = await import("node:fs/promises");
-        const { join: join27 } = await import("node:path");
+        const { join: join28 } = await import("node:path");
         const { load: load2 } = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
         const { CONFIG_DIR: CONFIG_DIR2, WORKSPACE_CONFIG_FILE: WORKSPACE_CONFIG_FILE2 } = await Promise.resolve().then(() => (init_constants(), exports_constants));
-        const configPath = join27(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
-        if (existsSync26(configPath)) {
+        const configPath = join28(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
+        if (existsSync27(configPath)) {
           const content = await readFile16(configPath, "utf-8");
           const config = load2(content);
           for (const entry of config.plugins ?? []) {
@@ -48228,9 +48546,9 @@ init_js_yaml();
 init_constants();
 init_workspace_config();
 init_workspace_modify();
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile16, writeFile as writeFile10 } from "node:fs/promises";
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 var PROJECT_MCP_CLIENTS2 = new Set([
   "claude",
   "codex",
@@ -48251,7 +48569,7 @@ function removeServerScopedProxyIntent(workspaceConfig, name) {
   }
 }
 function getConfigPath(workspacePath) {
-  return join27(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  return join28(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
 }
 async function readConfig(configPath) {
   const content = await readFile16(configPath, "utf-8");
@@ -48352,7 +48670,7 @@ async function clearWorkspaceMcpServerProxy(name, workspacePath = process.cwd())
 }
 async function removeWorkspaceMcpServer(name, workspacePath = process.cwd()) {
   const configPath = getConfigPath(workspacePath);
-  if (!existsSync26(configPath)) {
+  if (!existsSync27(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}`
@@ -48382,14 +48700,14 @@ async function removeWorkspaceMcpServer(name, workspacePath = process.cwd()) {
 }
 async function getWorkspaceMcpServer(name, workspacePath = process.cwd()) {
   const configPath = getConfigPath(workspacePath);
-  if (!existsSync26(configPath))
+  if (!existsSync27(configPath))
     return null;
   const workspaceConfig = await readConfig(configPath);
   return workspaceConfig.mcpServers?.[name] ?? null;
 }
 async function listWorkspaceMcpServers(workspacePath = process.cwd()) {
   const configPath = getConfigPath(workspacePath);
-  if (!existsSync26(configPath))
+  if (!existsSync27(configPath))
     return {};
   const workspaceConfig = await readConfig(configPath);
   return workspaceConfig.mcpServers ?? {};
@@ -48456,7 +48774,7 @@ import {
 import { mkdir as mkdir10, readFile as readFile17, rm as rm5, writeFile as writeFile11 } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { access } from "node:fs/promises";
-import { join as join28, dirname as dirname13 } from "node:path";
+import { join as join29, dirname as dirname14 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 
 // node_modules/zod/v4/core/core.js
@@ -56633,7 +56951,7 @@ function hashServerUrl(serverUrl) {
   return createHash3("sha256").update(serverUrl).digest("hex").slice(0, 16);
 }
 function getCacheDir(serverUrl) {
-  return join28(getHomeDir(), ".allagents", "oauth-proxy", hashServerUrl(serverUrl));
+  return join29(getHomeDir(), ".allagents", "oauth-proxy", hashServerUrl(serverUrl));
 }
 function getRequestInit(headers) {
   if (Object.keys(headers).length === 0) {
@@ -56656,7 +56974,7 @@ async function readJsonFile(path) {
   return JSON.parse(await readFile17(path, "utf-8"));
 }
 async function writePrivateFile(path, content) {
-  await mkdir10(dirname13(path), { recursive: true });
+  await mkdir10(dirname14(path), { recursive: true });
   await writeFile11(path, content, { encoding: "utf-8", mode: 384 });
 }
 function parseLoopbackPort(clientInfo) {
@@ -56747,10 +57065,10 @@ class FileOAuthClientProvider {
   constructor(port, serverUrl) {
     this.port = port;
     const cacheDir = getCacheDir(serverUrl);
-    this.clientInfoPath = join28(cacheDir, "client-info.json");
-    this.tokensPath = join28(cacheDir, "tokens.json");
-    this.verifierPath = join28(cacheDir, "code-verifier.txt");
-    this.discoveryPath = join28(cacheDir, "discovery.json");
+    this.clientInfoPath = join29(cacheDir, "client-info.json");
+    this.tokensPath = join29(cacheDir, "tokens.json");
+    this.verifierPath = join29(cacheDir, "code-verifier.txt");
+    this.discoveryPath = join29(cacheDir, "discovery.json");
     this.redirectUriValue = `http://127.0.0.1:${port}/callback`;
   }
   get redirectUrl() {
@@ -56884,7 +57202,7 @@ class FileOAuthClientProvider {
 }
 async function buildOAuthProvider(serverUrl) {
   const cacheDir = getCacheDir(serverUrl);
-  const cachedClientInfo = await readJsonFile(join28(cacheDir, "client-info.json"));
+  const cachedClientInfo = await readJsonFile(join29(cacheDir, "client-info.json"));
   let port = parseLoopbackPort(cachedClientInfo);
   if (!port) {
     port = await findFreePort();
@@ -58379,7 +58697,7 @@ var addPipeMethods = (spawned) => {
 };
 
 // node_modules/execa/lib/stream.js
-import { createReadStream, readFileSync as readFileSync6 } from "node:fs";
+import { createReadStream, readFileSync as readFileSync7 } from "node:fs";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 
 // node_modules/get-stream/source/contents.js
@@ -58575,7 +58893,7 @@ var getInputSync = ({ input, inputFile }) => {
     return input;
   }
   validateInputOptions(input);
-  return readFileSync6(inputFile);
+  return readFileSync7(inputFile);
 };
 var handleInputSync = (options2) => {
   const input = getInputSync(options2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "1.12.1-next.1",
+  "version": "1.13.0-next.1",
   "packageManager": "bun@1.3.12",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",