rulesync 9.7.0 → 9.8.0

package/dist/{import-DC9T1JlQ.js → import-Dioh9ca8.js}

@@ -322,7 +322,8 @@ const hooksProcessorToolTargetTuple = [
 	"junie",
 	"vibe",
 	"qwencode",
-	"reasonix"
+	"reasonix",
+	"grokcli"
 ];
 const permissionsProcessorToolTargetTuple = [
 	"amp",
@@ -6269,10 +6270,13 @@ const CLAUDE_HOOK_EVENTS = [
 * Hook events supported by Devin Local (native `.devin/` hooks).
 *
 * Devin Local adopts a Claude-Code-style lifecycle hooks surface. It documents
-* seven events: `PreToolUse`, `PostToolUse`, `PermissionRequest`,
-* `UserPromptSubmit`, `Stop`, `SessionStart`, and `SessionEnd`. The
+* eight events: `PreToolUse`, `PostToolUse`, `PermissionRequest`,
+* `UserPromptSubmit`, `Stop`, `SessionStart`, `SessionEnd`, and
+* `PostCompaction` (fires after context compaction; added in the Devin CLI
+* stable changelog — https://docs.devin.ai/cli/changelog/stable). The
 * tool/permission events (`PreToolUse`/`PostToolUse`/`PermissionRequest`) carry
-* a `matcher` (regex against `tool_name`); the session/turn events do not.
+* a `matcher` (regex against `tool_name`); the session/turn/compaction events
+* do not.
 *
 * Hooks live in `.devin/hooks.v1.json` (project, standalone — the hooks object
 * is the entire file) or under the `"hooks"` key of `.devin/config.json` /
@@ -6287,7 +6291,8 @@ const DEVIN_HOOK_EVENTS = [
 	"postToolUse",
 	"beforeSubmitPrompt",
 	"stop",
-	"permissionRequest"
+	"permissionRequest",
+	"postCompact"
 ];
 /** Hook events supported by OpenCode. */
 const OPENCODE_HOOK_EVENTS = [
@@ -6481,7 +6486,7 @@ const ANTIGRAVITY_HOOK_EVENTS = [
 * Hook events supported by AugmentCode (Auggie CLI).
 * Auggie mirrors Claude Code's lifecycle hooks but exposes a smaller set:
 * PreToolUse / PostToolUse (tool events, matcher-aware) plus the
-* SessionStart / SessionEnd / Stop session events (no matcher).
+* SessionStart / SessionEnd / Stop / Notification session events (no matcher).
 * @see https://docs.augmentcode.com/cli/hooks
 */
 const AUGMENTCODE_HOOK_EVENTS = [
@@ -6489,7 +6494,8 @@ const AUGMENTCODE_HOOK_EVENTS = [
 	"postToolUse",
 	"sessionStart",
 	"sessionEnd",
-	"stop"
+	"stop",
+	"notification"
 ];
 /**
 * Hook events supported by Mistral Vibe (mistral-vibe).
@@ -6541,6 +6547,10 @@ const JUNIE_HOOK_EVENTS = [
 * The Qwen-specific events
 * `TodoCreated`, `TodoCompleted`, and `StopFailure` map to the canonical
 * `todoCreated`, `todoCompleted`, and `stopFailure` events respectively.
+* Qwen's `HookEventName` enum (`packages/core/src/hooks/types.ts`) also documents
+* `PostToolBatch`, `UserPromptExpansion`, `PermissionDenied`, and
+* `InstructionsLoaded`, which map to the canonical `postToolBatch`,
+* `userPromptExpansion`, `permissionDenied`, and `instructionsLoaded` events.
 * @see https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/hooks.md
 */
 const QWENCODE_HOOK_EVENTS = [
@@ -6549,7 +6559,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preToolUse",
 	"postToolUse",
 	"postToolUseFailure",
+	"postToolBatch",
 	"beforeSubmitPrompt",
+	"userPromptExpansion",
 	"stop",
 	"stopFailure",
 	"subagentStart",
@@ -6557,7 +6569,9 @@ const QWENCODE_HOOK_EVENTS = [
 	"preCompact",
 	"postCompact",
 	"permissionRequest",
+	"permissionDenied",
 	"notification",
+	"instructionsLoaded",
 	"todoCreated",
 	"todoCompleted"
 ];
@@ -6567,11 +6581,11 @@ const QWENCODE_HOOK_EVENTS = [
 * Reasonix's `.reasonix/settings.json` (project) / `~/.reasonix/settings.json`
 * (global) documents a ten-event surface (`PreToolUse`, `PostToolUse`,
 * `UserPromptSubmit`, `Stop`, `PostLLMCall`, `SessionStart`, `SessionEnd`,
-* `SubagentStop`, `Notification`, `PreCompact`). The eight events with a clean
-* canonical equivalent are mapped: `PreToolUse`, `PostToolUse`,
+* `SubagentStop`, `Notification`, `PreCompact`). All ten have a clean canonical
+* equivalent and are mapped: `PreToolUse`, `PostToolUse`,
 * `UserPromptSubmit` ← `beforeSubmitPrompt`, `Stop`, `SessionStart`,
-* `SessionEnd`, `SubagentStop`, and `PostLLMCall` ← `postModelInvocation`.
-* (`Notification` and `PreCompact` have no canonical event and are left out.)
+* `SessionEnd`, `SubagentStop`, `PostLLMCall` ← `postModelInvocation`,
+* `Notification` ← `notification`, and `PreCompact` ← `preCompact`.
 * `match` (Reasonix's matcher field name) is honored only on
 * `PreToolUse`/`PostToolUse`, matching the canonical `matcher` field's
 * tool-event scoping used by other adapters.
@@ -6585,7 +6599,39 @@ const REASONIX_HOOK_EVENTS = [
 	"sessionStart",
 	"sessionEnd",
 	"subagentStop",
-	"postModelInvocation"
+	"postModelInvocation",
+	"notification",
+	"preCompact"
+];
+/**
+* Hook events supported by Grok CLI (xAI Grok Build).
+*
+* Grok Build documents a Claude-Code-compatible hooks surface with fourteen
+* PascalCase events, all of which map 1:1 onto an existing canonical arm:
+* `SessionStart`, `SessionEnd`, `UserPromptSubmit` ← `beforeSubmitPrompt`,
+* `PreToolUse`, `PostToolUse`, `PostToolUseFailure`, `PermissionDenied`,
+* `Stop`, `StopFailure`, `Notification`, `SubagentStart`, `SubagentStop`,
+* `PreCompact`, `PostCompact`. A `matcher` (a regex tested against the tool
+* name) is meaningful only on the tool-name events (`PreToolUse`, `PostToolUse`,
+* `PostToolUseFailure`, `PermissionDenied`), matching Claude Code's semantics;
+* the remaining lifecycle events are matcher-less.
+* @see https://docs.x.ai/build/features/hooks
+*/
+const GROKCLI_HOOK_EVENTS = [
+	"sessionStart",
+	"sessionEnd",
+	"beforeSubmitPrompt",
+	"preToolUse",
+	"postToolUse",
+	"postToolUseFailure",
+	"permissionDenied",
+	"stop",
+	"stopFailure",
+	"notification",
+	"subagentStart",
+	"subagentStop",
+	"preCompact",
+	"postCompact"
 ];
 /**
 * Hook events supported by Hermes Agent's native Shell Hooks system.
@@ -6659,6 +6705,7 @@ const HooksConfigSchema = z.looseObject({
 	junie: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	vibe: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	reasonix: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
+	grokcli: z.optional(z.looseObject({ hooks: z.optional(hooksRecordSchema) })),
 	qwencode: z.optional(z.looseObject({
 		hooks: z.optional(hooksRecordSchema),
 		disableAllHooks: z.optional(z.boolean())
@@ -6717,7 +6764,8 @@ const CANONICAL_TO_DEVIN_EVENT_NAMES = {
 	postToolUse: "PostToolUse",
 	beforeSubmitPrompt: "UserPromptSubmit",
 	stop: "Stop",
-	permissionRequest: "PermissionRequest"
+	permissionRequest: "PermissionRequest",
+	postCompact: "PostCompaction"
 };
 /**
 * Map Devin Local PascalCase event names to canonical camelCase.
@@ -6732,7 +6780,8 @@ const CANONICAL_TO_AUGMENTCODE_EVENT_NAMES = {
 	postToolUse: "PostToolUse",
 	sessionStart: "SessionStart",
 	sessionEnd: "SessionEnd",
-	stop: "Stop"
+	stop: "Stop",
+	notification: "Notification"
 };
 /**
 * Map AugmentCode PascalCase event names to canonical camelCase.
@@ -7002,7 +7051,9 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
 	postToolUseFailure: "PostToolUseFailure",
+	postToolBatch: "PostToolBatch",
 	beforeSubmitPrompt: "UserPromptSubmit",
+	userPromptExpansion: "UserPromptExpansion",
 	stop: "Stop",
 	subagentStart: "SubagentStart",
 	subagentStop: "SubagentStop",
@@ -7010,7 +7061,9 @@ const CANONICAL_TO_QWENCODE_EVENT_NAMES = {
 	preCompact: "PreCompact",
 	postCompact: "PostCompact",
 	permissionRequest: "PermissionRequest",
+	permissionDenied: "PermissionDenied",
 	notification: "Notification",
+	instructionsLoaded: "InstructionsLoaded",
 	todoCreated: "TodoCreated",
 	todoCompleted: "TodoCompleted"
 };
@@ -7032,12 +7085,40 @@ const CANONICAL_TO_REASONIX_EVENT_NAMES = {
 	sessionStart: "SessionStart",
 	sessionEnd: "SessionEnd",
 	subagentStop: "SubagentStop",
-	postModelInvocation: "PostLLMCall"
+	postModelInvocation: "PostLLMCall",
+	notification: "Notification",
+	preCompact: "PreCompact"
 };
 /**
 * Map Reasonix PascalCase event names to canonical camelCase.
 */
 const REASONIX_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_REASONIX_EVENT_NAMES).map(([k, v]) => [v, k]));
+/**
+* Map canonical camelCase event names to Grok CLI PascalCase.
+* Grok Build reuses the same Claude-style PascalCase event names, so each
+* canonical arm maps to its PascalCase equivalent.
+* @see https://docs.x.ai/build/features/hooks
+*/
+const CANONICAL_TO_GROKCLI_EVENT_NAMES = {
+	sessionStart: "SessionStart",
+	sessionEnd: "SessionEnd",
+	beforeSubmitPrompt: "UserPromptSubmit",
+	preToolUse: "PreToolUse",
+	postToolUse: "PostToolUse",
+	postToolUseFailure: "PostToolUseFailure",
+	permissionDenied: "PermissionDenied",
+	stop: "Stop",
+	stopFailure: "StopFailure",
+	notification: "Notification",
+	subagentStart: "SubagentStart",
+	subagentStop: "SubagentStop",
+	preCompact: "PreCompact",
+	postCompact: "PostCompact"
+};
+/**
+* Map Grok CLI PascalCase event names to canonical camelCase.
+*/
+const GROKCLI_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_GROKCLI_EVENT_NAMES).map(([k, v]) => [v, k]));
 //#endregion
 //#region src/features/hooks/tool-hooks-converter.ts
 function isToolMatcherEntry(x) {
@@ -7562,7 +7643,8 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 	noMatcherEvents: /* @__PURE__ */ new Set([
 		"sessionStart",
 		"sessionEnd",
-		"stop"
+		"stop",
+		"notification"
 	])
 };
 /**
@@ -8661,7 +8743,8 @@ const DEVIN_CONVERTER_CONFIG = {
 		"sessionStart",
 		"sessionEnd",
 		"stop",
-		"beforeSubmitPrompt"
+		"beforeSubmitPrompt",
+		"postCompact"
 	])
 };
 /**
@@ -8970,6 +9053,167 @@ var GooseHooks = class GooseHooks extends ToolHooks {
 	}
 };
 //#endregion
+//#region src/constants/grokcli-paths.ts
+/**
+* Grok Build CLI (xAI) configuration-layout conventions.
+*
+* Single source of truth for where Grok Build expects its files. Grok Build
+* stores MCP servers (and other settings) in a `config.toml` under `.grok/`,
+* with project/global scopes resolved by the directory the CLI runs in
+* (`./.grok/config.toml` vs `~/.grok/config.toml`).
+*
+* Verified against `grok` 0.2.54 (`grok mcp add --help`, `grok mcp add`):
+* `-s project` writes `./.grok/config.toml`, `-s user` writes
+* `~/.grok/config.toml`, both as a TOML `[mcp_servers.<name>]` table.
+* @see https://docs.x.ai/build/overview
+*/
+/** Root directory for Grok Build configuration, relative to the scope root. */
+const GROKCLI_DIR = ".grok";
+/** MCP servers and other settings live in `config.toml` under `.grok/`. */
+const GROKCLI_MCP_FILE_NAME = "config.toml";
+/**
+* Shared Grok CLI config file (`config.toml`). MCP servers, the `[ui]`
+* permission mode, and other settings all live here; permissions reuse the same
+* file name as MCP since Grok consolidates everything into one config.
+*/
+const GROKCLI_CONFIG_FILE_NAME = "config.toml";
+/** Skills directory under `.grok/` (project: `./.grok/skills`, global: `~/.grok/skills`). */
+const GROKCLI_SKILLS_DIR_PATH = join(GROKCLI_DIR, "skills");
+/**
+* Hooks directory under `.grok/`. Grok Build discovers hook config files from
+* `.grok/hooks/*.json` (project) and `~/.grok/hooks/*.json` (global), each a
+* standalone JSON file using the Claude-Code-compatible nested `{ hooks: { … } }`
+* shape. rulesync writes all its hooks into a single `rulesync.json`.
+* @see https://docs.x.ai/build/features/hooks
+*/
+const GROKCLI_HOOKS_DIR_PATH = join(GROKCLI_DIR, "hooks");
+/** rulesync-managed Grok hooks file under `.grok/hooks/`. */
+const GROKCLI_HOOKS_FILE_NAME = "rulesync.json";
+/**
+* Subagents (agent profiles) directory under `.grok/`. Grok Build discovers
+* agent definitions from `.grok/agents/*.md` (project) and `~/.grok/agents/*.md`
+* (global), each a Markdown file with YAML frontmatter (verified via
+* `grok inspect`; format matches the bundled `~/.grok/bundled/agents/*.md`).
+*/
+const GROKCLI_AGENTS_DIR_PATH = join(GROKCLI_DIR, "agents");
+/**
+* Instruction file. Grok reads the AGENTS.md instruction-file family natively,
+* including the user-level `~/.grok/AGENTS.md` for global rules (verified via
+* `grok inspect`, consistent with the `.grok/` global discovery used by the
+* MCP/skills/subagents adapters).
+*/
+const GROKCLI_RULE_FILE_NAME = "AGENTS.md";
+//#endregion
+//#region src/features/hooks/grokcli-hooks.ts
+const GROKCLI_CONVERTER_CONFIG = {
+	supportedEvents: GROKCLI_HOOK_EVENTS,
+	canonicalToToolEventNames: CANONICAL_TO_GROKCLI_EVENT_NAMES,
+	toolToCanonicalEventNames: GROKCLI_TO_CANONICAL_EVENT_NAMES,
+	projectDirVar: "",
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	noMatcherEvents: /* @__PURE__ */ new Set([
+		"sessionStart",
+		"sessionEnd",
+		"beforeSubmitPrompt",
+		"stop",
+		"stopFailure",
+		"notification",
+		"subagentStart",
+		"subagentStop",
+		"preCompact",
+		"postCompact"
+	])
+};
+/**
+* Hooks generator for Grok CLI (xAI Grok Build).
+*
+* Grok Build adopts a Claude-Code-compatible lifecycle hooks model: each event
+* maps to an array of `{ matcher?, hooks: [{ type, command, timeout? }] }`
+* matcher groups under a top-level `hooks` key. rulesync writes all its hooks
+* into a single standalone `rulesync.json` file discovered from
+* `.grok/hooks/*.json` (project) and `~/.grok/hooks/*.json` (global). The file
+* is dedicated to hooks and owned wholesale by rulesync, so it may be deleted
+* as an orphan.
+*
+* @see https://docs.x.ai/build/features/hooks
+*/
+var GrokcliHooks = class GrokcliHooks extends ToolHooks {
+	constructor(params) {
+		super({
+			...params,
+			fileContent: params.fileContent ?? "{}"
+		});
+	}
+	static getSettablePaths(_options = {}) {
+		return {
+			relativeDirPath: GROKCLI_HOOKS_DIR_PATH,
+			relativeFilePath: GROKCLI_HOOKS_FILE_NAME
+		};
+	}
+	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
+		const paths = GrokcliHooks.getSettablePaths({ global });
+		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "{\"hooks\":{}}";
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	static async fromRulesyncHooks({ outputRoot = process.cwd(), rulesyncHooks, validate = true, global = false, logger }) {
+		const paths = GrokcliHooks.getSettablePaths({ global });
+		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const config = rulesyncHooks.getJson();
+		const grokHooks = canonicalToToolHooks({
+			config,
+			toolOverrideHooks: config.grokcli?.hooks,
+			converterConfig: GROKCLI_CONVERTER_CONFIG,
+			logger
+		});
+		await readOrInitializeFileContent(filePath, JSON.stringify({ hooks: {} }, null, 2));
+		const fileContent = JSON.stringify({ hooks: grokHooks }, null, 2);
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath: paths.relativeDirPath,
+			relativeFilePath: paths.relativeFilePath,
+			fileContent,
+			validate
+		});
+	}
+	toRulesyncHooks() {
+		let parsed;
+		try {
+			parsed = JSON.parse(this.getFileContent());
+		} catch (error) {
+			throw new Error(`Failed to parse Grok hooks content in ${join(this.getRelativeDirPath(), this.getRelativeFilePath())}: ${formatError(error)}`, { cause: error });
+		}
+		const hooks = toolHooksToCanonical({
+			hooks: isRecord(parsed) && isRecord(parsed.hooks) ? parsed.hooks : {},
+			converterConfig: GROKCLI_CONVERTER_CONFIG
+		});
+		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify({
+			version: 1,
+			hooks
+		}, null, 2) });
+	}
+	validate() {
+		return {
+			success: true,
+			error: null
+		};
+	}
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+		return new GrokcliHooks({
+			outputRoot,
+			relativeDirPath,
+			relativeFilePath,
+			fileContent: JSON.stringify({ hooks: {} }, null, 2),
+			validate: false
+		});
+	}
+};
+//#endregion
 //#region src/features/hooks/hermesagent-hooks.ts
 /**
 * Canonical events that map to a Hermes tool-call event (`pre_tool_call` /
@@ -10176,9 +10420,9 @@ function reasonixHooksToCanonical(hooks) {
 * Reasonix hooks live in a Claude-Code-style but standalone JSON file —
 * `.reasonix/settings.json` (project) or `~/.reasonix/settings.json`
 * (global) — separate from the `[permissions]`/`[[plugins]]` TOML config.
-* The eight upstream events with a clean canonical equivalent are mapped:
+* All ten upstream events have a clean canonical equivalent and are mapped:
 * PreToolUse/PostToolUse/UserPromptSubmit/Stop plus SessionStart/SessionEnd/
-* SubagentStop/PostLLMCall (see REASONIX_HOOK_EVENTS).
+* SubagentStop/PostLLMCall/Notification/PreCompact (see REASONIX_HOOK_EVENTS).
 * @see https://github.com/esengine/DeepSeek-Reasonix/blob/main-v2/docs/DESKTOP_HOOKS.zh-CN.md
 */
 var ReasonixHooks = class ReasonixHooks extends ToolHooks {
@@ -10766,6 +11010,17 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 		supportedEvents: REASONIX_HOOK_EVENTS,
 		supportedHookTypes: ["command"],
 		supportsMatcher: true
+	}],
+	["grokcli", {
+		class: GrokcliHooks,
+		meta: {
+			supportsProject: true,
+			supportsGlobal: true,
+			supportsImport: true
+		},
+		supportedEvents: GROKCLI_HOOK_EVENTS,
+		supportedHookTypes: ["command"],
+		supportsMatcher: true
 	}]
 ]);
 const hooksProcessorToolTargets = [...toolHooksFactories.entries()].filter(([, f]) => f.meta.supportsProject).map(([t]) => t);
@@ -13021,7 +13276,13 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 			...rest,
 			validate: false
 		});
-		this.toml = smolToml.parse(this.fileContent);
+		let toml;
+		try {
+			toml = smolToml.parse(this.fileContent);
+		} catch (error) {
+			throw new Error(`Failed to parse Codex CLI config at ${this.getFilePath()}: ${formatError(error)}`, { cause: error });
+		}
+		this.toml = toml;
 		if (rest.validate) {
 			const result = this.validate();
 			if (!result.success) throw result.error;
@@ -13057,7 +13318,12 @@ var CodexcliMcp = class CodexcliMcp extends ToolMcp {
 		const paths = this.getSettablePaths({ global });
 		const configTomlFilePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const configTomlFileContent = await readFileContentOrNull(configTomlFilePath) ?? "";
-		const configToml = smolToml.parse(configTomlFileContent || smolToml.stringify({}));
+		let configToml;
+		try {
+			configToml = smolToml.parse(configTomlFileContent || smolToml.stringify({}));
+		} catch (error) {
+			throw new Error(`Failed to parse existing Codex CLI config at ${configTomlFilePath}: ${formatError(error)}`, { cause: error });
+		}
 		const strippedMcpServers = rulesyncMcp.getMcpServers();
 		const rawMcpServers = rulesyncMcp.getJson().mcpServers;
 		const converted = convertToCodexFormat(Object.fromEntries(Object.entries(strippedMcpServers).map(([serverName, serverConfig]) => {
@@ -14031,47 +14297,6 @@ var GooseMcp = class GooseMcp extends ToolMcp {
 	}
 };
 //#endregion
-//#region src/constants/grokcli-paths.ts
-/**
-* Grok Build CLI (xAI) configuration-layout conventions.
-*
-* Single source of truth for where Grok Build expects its files. Grok Build
-* stores MCP servers (and other settings) in a `config.toml` under `.grok/`,
-* with project/global scopes resolved by the directory the CLI runs in
-* (`./.grok/config.toml` vs `~/.grok/config.toml`).
-*
-* Verified against `grok` 0.2.54 (`grok mcp add --help`, `grok mcp add`):
-* `-s project` writes `./.grok/config.toml`, `-s user` writes
-* `~/.grok/config.toml`, both as a TOML `[mcp_servers.<name>]` table.
-* @see https://docs.x.ai/build/overview
-*/
-/** Root directory for Grok Build configuration, relative to the scope root. */
-const GROKCLI_DIR = ".grok";
-/** MCP servers and other settings live in `config.toml` under `.grok/`. */
-const GROKCLI_MCP_FILE_NAME = "config.toml";
-/**
-* Shared Grok CLI config file (`config.toml`). MCP servers, the `[ui]`
-* permission mode, and other settings all live here; permissions reuse the same
-* file name as MCP since Grok consolidates everything into one config.
-*/
-const GROKCLI_CONFIG_FILE_NAME = "config.toml";
-/** Skills directory under `.grok/` (project: `./.grok/skills`, global: `~/.grok/skills`). */
-const GROKCLI_SKILLS_DIR_PATH = join(GROKCLI_DIR, "skills");
-/**
-* Subagents (agent profiles) directory under `.grok/`. Grok Build discovers
-* agent definitions from `.grok/agents/*.md` (project) and `~/.grok/agents/*.md`
-* (global), each a Markdown file with YAML frontmatter (verified via
-* `grok inspect`; format matches the bundled `~/.grok/bundled/agents/*.md`).
-*/
-const GROKCLI_AGENTS_DIR_PATH = join(GROKCLI_DIR, "agents");
-/**
-* Instruction file. Grok reads the AGENTS.md instruction-file family natively,
-* including the user-level `~/.grok/AGENTS.md` for global rules (verified via
-* `grok inspect`, consistent with the `.grok/` global discovery used by the
-* MCP/skills/subagents adapters).
-*/
-const GROKCLI_RULE_FILE_NAME = "AGENTS.md";
-//#endregion
 //#region src/features/mcp/grokcli-mcp.ts
 const MAX_REMOVE_EMPTY_ENTRIES_DEPTH = 32;
 /**
@@ -14231,6 +14456,54 @@ function resolveHermesTimeout(config) {
 	if (typeof config.networkTimeout === "number") return config.networkTimeout;
 }
 /**
+* Copies the advanced Hermes-recognized per-server fields that have no canonical
+* alias — `auth` (`oauth` for OAuth 2.1/PKCE), mTLS `client_cert` (string PEM
+* path, or `[cert, key]`/`[cert, key, password]` list) and `client_key`,
+* `connect_timeout` (seconds), and `supports_parallel_tool_calls` — verbatim
+* from `source` to `target`. Field names are identical on both sides (the
+* canonical `McpServerSchema` is a `looseObject`), so this serves export and
+* import alike. See the Hermes mcp-config-reference.
+*/
+function copyHermesAdvancedFields(source, target) {
+	if (typeof source.auth === "string") target.auth = source.auth;
+	if (typeof source.client_cert === "string" || isStringArray(source.client_cert)) target.client_cert = source.client_cert;
+	if (typeof source.client_key === "string") target.client_key = source.client_key;
+	if (typeof source.connect_timeout === "number") target.connect_timeout = source.connect_timeout;
+	if (typeof source.supports_parallel_tool_calls === "boolean") target.supports_parallel_tool_calls = source.supports_parallel_tool_calls;
+}
+/**
+* Builds Hermes's per-server `tools` block from a canonical server config. The
+* canonical `enabledTools`/`disabledTools` arrays become `include`/`exclude`,
+* and the boolean `promptsEnabled`/`resourcesEnabled` toggles become Hermes's
+* `prompts`/`resources` capability flags. Returns an empty object when the
+* server has no tool scoping (the caller omits the block in that case).
+*
+* Note: `promptsEnabled`/`resourcesEnabled` are canonical top-level keys rather
+* than a nested canonical `tools` object, because canonical `McpServerSchema.tools`
+* is reserved as a `string[]` (used by other tools) — reusing it for an object
+* would fail validation on the next `generate`.
+*/
+function buildHermesToolsBlock(config) {
+	const tools = {};
+	if (isStringArray(config.enabledTools)) tools.include = config.enabledTools;
+	if (isStringArray(config.disabledTools)) tools.exclude = config.disabledTools;
+	if (typeof config.promptsEnabled === "boolean") tools.prompts = config.promptsEnabled;
+	if (typeof config.resourcesEnabled === "boolean") tools.resources = config.resourcesEnabled;
+	return tools;
+}
+/**
+* Applies a Hermes per-server `tools` block back onto a canonical server config
+* (inverse of {@link buildHermesToolsBlock}): `include`/`exclude` become
+* `enabledTools`/`disabledTools`, and `prompts`/`resources` become the boolean
+* `promptsEnabled`/`resourcesEnabled` top-level toggles.
+*/
+function applyHermesToolsBlock(hermesTools, server) {
+	if (isStringArray(hermesTools.include)) server.enabledTools = hermesTools.include;
+	if (isStringArray(hermesTools.exclude)) server.disabledTools = hermesTools.exclude;
+	if (typeof hermesTools.prompts === "boolean") server.promptsEnabled = hermesTools.prompts;
+	if (typeof hermesTools.resources === "boolean") server.resourcesEnabled = hermesTools.resources;
+}
+/**
 * Converts a single rulesync canonical MCP server into a Hermes `mcp_servers:` entry.
 *
 * Hermes is close to the MCP spec but not identical: `command` must be a single
@@ -14264,9 +14537,8 @@ function convertServerToHermes(config) {
 	if (config.disabled === true) out.enabled = false;
 	const timeout = resolveHermesTimeout(config);
 	if (timeout !== void 0) out.timeout = timeout;
-	const tools = {};
-	if (isStringArray(config.enabledTools)) tools.include = config.enabledTools;
-	if (isStringArray(config.disabledTools)) tools.exclude = config.disabledTools;
+	copyHermesAdvancedFields(config, out);
+	const tools = buildHermesToolsBlock(config);
 	if (Object.keys(tools).length > 0) out.tools = tools;
 	return out;
 }
@@ -14309,10 +14581,8 @@ function convertFromHermesFormat(mcpServers) {
 		if (isPlainObject$1(config.headers)) server.headers = omitPrototypePollutionKeys(config.headers);
 		if (config.enabled === false) server.disabled = true;
 		if (typeof config.timeout === "number") server.networkTimeout = config.timeout;
-		if (isRecord(config.tools)) {
-			if (isStringArray(config.tools.include)) server.enabledTools = config.tools.include;
-			if (isStringArray(config.tools.exclude)) server.disabledTools = config.tools.exclude;
-		}
+		copyHermesAdvancedFields(config, server);
+		if (isRecord(config.tools)) applyHermesToolsBlock(config.tools, server);
 		result[name] = server;
 	}
 	return result;
@@ -16607,18 +16877,27 @@ const CursorPermissionsOverrideSchema = z.looseObject({
 * Tool-scoped override block for Qwen Code. Qwen's `settings.json` exposes
 * autonomy/sandbox controls with no canonical permission category — under
 * `tools` (`approvalMode` = plan/default/auto-edit/auto/yolo, `autoAccept`,
-* `sandbox`, `sandboxImage`, `disabled`) and `security` (`folderTrust`). Fields
-* placed here are merged into the matching `settings.json` group and emitted
-* only for Qwen, while the shared `permission` block continues to drive the
-* `permissions.allow`/`ask`/`deny` arrays. Kept `looseObject` (verbatim
-* passthrough) so any current or future `tools`/`security` key can be authored.
+* `sandbox`, `sandboxImage`, `disabled`) and `security` (`folderTrust`). It also
+* exposes `permissions.autoMode` (the Auto Mode classifier config:
+* `hints.{allow,softDeny,hardDeny}`, `environment`, `classifyAllShell` — see
+* https://qwenlm.github.io/qwen-code-docs/en/users/features/auto-mode/), which
+* likewise has no canonical category. Fields placed here are merged into the
+* matching `settings.json` group and emitted only for Qwen, while the shared
+* `permission` block continues to drive the `permissions.allow`/`ask`/`deny`
+* arrays. Kept `looseObject` (verbatim passthrough) so any current or future
+* `tools`/`security`/`autoMode` key can be authored.
 *
 * @example
-* { "tools": { "approvalMode": "auto-edit" }, "security": { "folderTrust": { "enabled": true } } }
+* {
+*   "tools": { "approvalMode": "auto-edit" },
+*   "security": { "folderTrust": { "enabled": true } },
+*   "autoMode": { "hints": { "allow": ["Running tests"] }, "classifyAllShell": true }
+* }
 */
 const QwencodePermissionsOverrideSchema = z.looseObject({
 	tools: z.optional(z.looseObject({})),
-	security: z.optional(z.looseObject({}))
+	security: z.optional(z.looseObject({})),
+	autoMode: z.optional(z.looseObject({}))
 });
 /**
 * Tool-scoped override block for Reasonix. Reasonix has security axes orthogonal
@@ -16645,9 +16924,11 @@ const ReasonixPermissionsOverrideSchema = z.looseObject({
 * exposes security controls with no canonical per-command allow/ask/deny slot —
 * `commandBlocklist` (a hard-block tier that can never be approved, distinct from
 * an approvable `deny`), `networkPolicy` (`allowedIps`), `sandbox`
-* (`enabled`/`mode`/`filesystem`/`network`), `mcpPolicy`, `enableDroidShield`,
+* (`enabled`/`mode`/`filesystem`/`network`), `mcpPolicy`,
+* `mcpAutonomyOverrides` (per-MCP-tool autonomy levels), `enableDroidShield`,
 * and autonomy settings (`sessionDefaultSettings`, `maxAutonomyLevel`,
-* `interactionMode`). Fields placed here are merged into `settings.json` and
+* `subagentAutonomyLevel`, `interactionMode`). Fields placed here are merged
+* into `settings.json` and
 * emitted only for Factory Droid, while the shared `permission` block continues
 * to drive `commandAllowlist`/`commandDenylist`. Kept `looseObject` passthrough.
 *
@@ -16840,6 +17121,41 @@ const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(
 	}))
 })) });
 /**
+* Codex CLI's approval-workflow policy. Serialized as a kebab-case string in
+* `.codex/config.toml`. `on-failure` is a legacy alias for `on-request` that
+* Codex still accepts, so it is included so existing configs round-trip. The
+* granular table form (`{ granular = { … } }`) is modeled separately in the
+* override union.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexApprovalPolicySchema = z.enum([
+	"untrusted",
+	"on-request",
+	"on-failure",
+	"never"
+]);
+/**
+* Codex CLI's classic sandbox mode. Serialized as a kebab-case string in
+* `.codex/config.toml`.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexSandboxModeSchema = z.enum([
+	"read-only",
+	"workspace-write",
+	"danger-full-access"
+]);
+/**
+* Codex CLI's reviewer for approval requests. `guardian_subagent` is a legacy
+* value Codex still accepts for backward compatibility, so it is included so
+* existing configs round-trip through the rulesync model.
+* @see https://learn.chatgpt.com/docs/config-file/config-reference
+*/
+const CodexApprovalsReviewerSchema = z.enum([
+	"user",
+	"auto_review",
+	"guardian_subagent"
+]);
+/**
 * Codex CLI-scoped permission override.
 *
 * Codex CLI's permission surface is richer than the canonical allow/ask/deny
@@ -16848,15 +17164,16 @@ const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(
 * override whose fields are written verbatim as top-level `.codex/config.toml`
 * keys (the override wins per key; existing sibling keys the user set directly
 * are preserved):
-* - `approval_policy` — `untrusted` | `on-request` | `never`, or a
-*   `{ granular = { … } }` table (kept verbatim; the granular schema has
-*   required fields that are brittle to model as typed keys).
+* - `approval_policy` — `untrusted` | `on-request` (legacy alias `on-failure`) |
+*   `never`, or a `{ granular = { … } }` table (kept verbatim; the granular
+*   schema has required fields that are brittle to model as typed keys).
 * - `sandbox_mode` — `read-only` | `workspace-write` | `danger-full-access`,
 *   with the sibling `sandbox_workspace_write` table (`network_access`,
 *   `writable_roots`, …).
 * - `apps` — per-app tool gating (`apps.<id>.tools.<tool>.approval_mode` /
 *   `.enabled`, `apps.<id>.default_tools_approval_mode`).
-* - `approvals_reviewer` — the reviewer-approval surface.
+* - `approvals_reviewer` — the reviewer-approval surface (`user` | `auto_review`
+*   | `guardian_subagent`), or a table for the richer reviewer config.
 *
 * Two surfaces are deliberately NOT authorable here so the override can never
 * clobber a feature-owned key: `mcp_servers.*` per-MCP gating is owned by the
@@ -16874,11 +17191,11 @@ const KiroPermissionsOverrideSchema = z.looseObject({ toolsSettings: z.optional(
 *   "sandbox_workspace_write": { "network_access": true } }
 */
 const CodexcliPermissionsOverrideSchema = z.looseObject({
-	approval_policy: z.optional(z.union([z.string(), z.looseObject({})])),
-	sandbox_mode: z.optional(z.string()),
+	approval_policy: z.optional(z.union([CodexApprovalPolicySchema, z.looseObject({})])),
+	sandbox_mode: z.optional(CodexSandboxModeSchema),
 	sandbox_workspace_write: z.optional(z.looseObject({})),
 	apps: z.optional(z.looseObject({})),
-	approvals_reviewer: z.optional(z.union([z.string(), z.looseObject({})]))
+	approvals_reviewer: z.optional(z.union([CodexApprovalsReviewerSchema, z.looseObject({})]))
 });
 /**
 * Permissions configuration.
@@ -19739,9 +20056,11 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"networkPolicy",
 	"sandbox",
 	"mcpPolicy",
+	"mcpAutonomyOverrides",
 	"enableDroidShield",
 	"sessionDefaultSettings",
 	"maxAutonomyLevel",
+	"subagentAutonomyLevel",
 	"interactionMode"
 ];
 /**
@@ -20099,7 +20418,6 @@ function convertGoosePermissionConfigToRulesync(userPermission) {
 }
 //#endregion
 //#region src/features/permissions/grokcli-permissions.ts
-const GROKCLI_GLOBAL_ONLY_MESSAGE = "Grok CLI permissions are global-only; use --global to sync ~/.grok/config.toml";
 const GROKCLI_UI_KEY = "ui";
 const GROKCLI_PERMISSION_MODE_KEY = "permission_mode";
 const GROKCLI_PERMISSION_KEY = "permission";
@@ -20201,13 +20519,19 @@ function parseGrokEntry(entry) {
 * compatibility with older Grok versions: `always-approve` when the config is
 * pure-`allow`, otherwise `ask` (conservative — it is never `always-approve`
 * while any `deny`/`ask` rule exists, so it never contradicts the fine-grained
-* arrays).
-*
-* This surface is **global only** — the adapter syncs the user-level
-* `~/.grok/config.toml`. (Grok also supports a project-scoped `[permission]`
-* file; project scope is not modeled here.) The shared config is merged in
+* arrays). It is a user-level UI setting, so it is only written in global scope
+* (see below).
+*
+* Both scopes are supported: the adapter syncs the project-level
+* `./.grok/config.toml` (default) and the user-level `~/.grok/config.toml`
+* (with `--global`). Grok documents that "Project configs are limited to MCP
+* servers, plugins, and permission rules, not full user configs"
+* (https://docs.x.ai/build/settings), so the project config carries only the
+* fine-grained `[permission]` rules; the coarse `[ui] permission_mode` UI toggle
+* is written in global scope only. The shared config is merged in
 * place: rulesync owns the `[permission]` `allow`/`deny`/`ask` entries for the
-* tools it models and the `[ui] permission_mode` value, while every other key
+* tools it models and (in global scope) the `[ui] permission_mode` value, while
+* every other key
 * (e.g. `[mcp_servers]`, `[permission] rules`, `[sandbox]`) and any user-authored
 * entries for tools rulesync cannot model (e.g. `WebSearch`) are preserved. The
 * file is never deleted.
@@ -20229,7 +20553,6 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 		};
 	}
 	static async fromFile({ outputRoot = process.cwd(), validate = true, global = false }) {
-		if (!global) throw new Error(GROKCLI_GLOBAL_ONLY_MESSAGE);
 		const paths = GrokcliPermissions.getSettablePaths({ global });
 		const fileContent = await readFileContentOrNull(join(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "";
 		return new GrokcliPermissions({
@@ -20238,11 +20561,10 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			relativeFilePath: paths.relativeFilePath,
 			fileContent,
 			validate,
-			global: true
+			global
 		});
 	}
 	static async fromRulesyncPermissions({ outputRoot = process.cwd(), rulesyncPermissions, logger, global = false }) {
-		if (!global) throw new Error(GROKCLI_GLOBAL_ONLY_MESSAGE);
 		const paths = GrokcliPermissions.getSettablePaths({ global });
 		const filePath = join(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
 		const existingContent = await readFileContentOrNull(filePath) ?? "";
@@ -20261,11 +20583,10 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			deny: buckets.deny,
 			ask: buckets.ask
 		};
-		const mode = deriveGrokPermissionMode(config);
-		const ui = {
+		const uiPatch = global ? { [GROKCLI_UI_KEY]: {
 			...isRecord(parsed[GROKCLI_UI_KEY]) ? parsed[GROKCLI_UI_KEY] : {},
-			[GROKCLI_PERMISSION_MODE_KEY]: mode
-		};
+			[GROKCLI_PERMISSION_MODE_KEY]: deriveGrokPermissionMode(config)
+		} } : {};
 		return new GrokcliPermissions({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
@@ -20276,12 +20597,12 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 				existingContent,
 				patch: {
 					[GROKCLI_PERMISSION_KEY]: permission,
-					[GROKCLI_UI_KEY]: ui
+					...uiPatch
 				},
 				filePath
 			}),
 			validate: true,
-			global: true
+			global
 		});
 	}
 	toRulesyncPermissions() {
@@ -20302,14 +20623,14 @@ var GrokcliPermissions = class GrokcliPermissions extends ToolPermissions {
 			error: null
 		};
 	}
-	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath }) {
+	static forDeletion({ outputRoot = process.cwd(), relativeDirPath, relativeFilePath, global = false }) {
 		return new GrokcliPermissions({
 			outputRoot,
 			relativeDirPath,
 			relativeFilePath,
 			fileContent: "",
 			validate: false,
-			global: true
+			global
 		});
 	}
 };
@@ -21224,6 +21545,22 @@ const CANONICAL_PERMISSION_CATEGORIES = /* @__PURE__ */ new Set([
 	"notebookedit",
 	"agent"
 ]);
+/**
+* Translate between rulesync's canonical permission category names and
+* OpenCode's native permission keys. OpenCode has no `agent` key — subagent
+* launches are gated by the `task` key (see the documented key list at
+* https://opencode.ai/docs/permissions/). Without this translation a canonical
+* `agent: deny` would be written verbatim into `opencode.json` and silently
+* ignored by OpenCode. Unknown names pass through unchanged.
+*/
+const CANONICAL_TO_OPENCODE_PERMISSION_KEYS = { agent: "task" };
+const OPENCODE_TO_CANONICAL_PERMISSION_KEYS = Object.fromEntries(Object.entries(CANONICAL_TO_OPENCODE_PERMISSION_KEYS).map(([canonical, opencode]) => [opencode, canonical]));
+function toOpencodePermissionKey(canonical) {
+	return CANONICAL_TO_OPENCODE_PERMISSION_KEYS[canonical] ?? canonical;
+}
+function toCanonicalPermissionKey(opencodeKey) {
+	return OPENCODE_TO_CANONICAL_PERMISSION_KEYS[opencodeKey] ?? opencodeKey;
+}
 function isSharedPermissionCategory(category) {
 	return category === "*" || CANONICAL_PERMISSION_CATEGORIES.has(category) || category.startsWith("mcp__");
 }
@@ -21290,6 +21627,8 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 		}
 		const rulesyncJson = rulesyncPermissions.getJson();
 		const overridePermission = rulesyncJson.opencode?.permission ?? {};
+		const sharedPermission = {};
+		for (const [category, value] of Object.entries(rulesyncJson.permission ?? {})) sharedPermission[toOpencodePermissionKey(category)] = value;
 		return new OpencodePermissions({
 			outputRoot,
 			relativeDirPath: basePaths.relativeDirPath,
@@ -21299,7 +21638,7 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 				feature: "permissions",
 				existingContent: fileContent ?? "",
 				patch: { permission: {
-					...rulesyncJson.permission,
+					...sharedPermission,
 					...overridePermission
 				} },
 				filePath: join(jsonDir, relativeFilePath)
@@ -21315,8 +21654,11 @@ var OpencodePermissions = class OpencodePermissions extends ToolPermissions {
 		}
 		const shared = {};
 		const overrideOnly = {};
-		for (const [category, value] of Object.entries(rawPermission)) if (isSharedPermissionCategory(category)) shared[category] = typeof value === "string" ? { "*": value } : value;
-		else overrideOnly[category] = value;
+		for (const [category, value] of Object.entries(rawPermission)) {
+			const canonicalCategory = toCanonicalPermissionKey(category);
+			if (isSharedPermissionCategory(canonicalCategory)) shared[canonicalCategory] = typeof value === "string" ? { "*": value } : value;
+			else overrideOnly[category] = value;
+		}
 		const json = Object.keys(overrideOnly).length > 0 ? {
 			permission: shared,
 			opencode: { permission: overrideOnly }
@@ -21441,6 +21783,7 @@ const QWEN_OVERRIDE_TOOLS_KEYS = [
 	"disabled"
 ];
 const QWEN_OVERRIDE_SECURITY_KEYS = ["folderTrust"];
+const QWEN_OVERRIDE_PERMISSIONS_KEYS = ["autoMode"];
 function asPlainRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -21512,8 +21855,9 @@ var QwencodePermissions = class QwencodePermissions extends ToolPermissions {
 		else delete mergedPermissions.ask;
 		if (mergedDeny.length > 0) mergedPermissions.deny = mergedDeny;
 		else delete mergedPermissions.deny;
-		const patch = { permissions: mergedPermissions };
 		const override = config.qwencode;
+		if (override?.autoMode !== void 0) mergedPermissions.autoMode = override.autoMode;
+		const patch = { permissions: mergedPermissions };
 		if (override?.tools !== void 0) patch.tools = {
 			...asPlainRecord(settings.tools),
 			...asPlainRecord(override.tools)
@@ -21555,9 +21899,11 @@ var QwencodePermissions = class QwencodePermissions extends ToolPermissions {
 		});
 		const overrideTools = pickQwenOverrideKeys(settings.tools, QWEN_OVERRIDE_TOOLS_KEYS);
 		const overrideSecurity = pickQwenOverrideKeys(settings.security, QWEN_OVERRIDE_SECURITY_KEYS);
+		const overridePermissions = pickQwenOverrideKeys(settings.permissions, QWEN_OVERRIDE_PERMISSIONS_KEYS);
 		const qwencodeOverride = {};
 		if (Object.keys(overrideTools).length > 0) qwencodeOverride.tools = overrideTools;
 		if (Object.keys(overrideSecurity).length > 0) qwencodeOverride.security = overrideSecurity;
+		if (overridePermissions.autoMode !== void 0) qwencodeOverride.autoMode = overridePermissions.autoMode;
 		const result = { ...config };
 		if (Object.keys(qwencodeOverride).length > 0) result.qwencode = qwencodeOverride;
 		return this.toRulesyncPermissionsDefault({ fileContent: JSON.stringify(result, null, 2) });
@@ -23066,7 +23412,7 @@ const toolPermissionsFactories = /* @__PURE__ */ new Map([
 	["grokcli", {
 		class: GrokcliPermissions,
 		meta: {
-			supportsProject: false,
+			supportsProject: true,
 			supportsGlobal: true,
 			supportsImport: true
 		}
@@ -39591,4 +39937,4 @@ async function importPermissionsCore(params) {
 //#endregion
 export { removeTempDirectory as $, RulesyncCommand as A, checkPathTraversal as B, RulesyncHooks as C, RULESYNC_RULES_RELATIVE_DIR_PATH as Ct, CLAUDECODE_MEMORIES_DIR_NAME as D, formatError as Dt, CLAUDECODE_LOCAL_RULE_FILE_NAME as E, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Et, findControlCharacter as F, findFilesByGlobs as G, directoryExists as H, ConsoleLogger as I, isSymlink as J, getFileSize as K, JsonLogger as L, stringifyFrontmatter as M, loadYaml as N, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as O, ALL_FEATURES as Ot, ConfigResolver as P, removeFile as Q, CLIError as R, HooksProcessor as S, RULESYNC_RELATIVE_DIR_PATH as St, CLAUDECODE_DIR as T, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Tt, ensureDir as U, createTempDirectory as V, fileExists as W, readFileContent as X, listDirectoryFiles as Y, removeDirectory as Z, RulesyncPermissions as _, RULESYNC_MCP_RELATIVE_FILE_PATH as _t, convertFromTool as a, MAX_FILE_SIZE as at, IgnoreProcessor as b, RULESYNC_PERMISSIONS_FILE_NAME as bt, RulesyncRuleFrontmatterSchema as c, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as ct, RulesyncSubagentFrontmatterSchema as d, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as dt, toPosixPath as et, SkillsProcessor as f, RULESYNC_HOOKS_FILE_NAME as ft, SKILL_FILE_NAME as g, RULESYNC_MCP_FILE_NAME as gt, RulesyncSkillFrontmatterSchema as h, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as ht, getProcessorRegistryEntry as i, ToolTargetSchema as it, RulesyncCommandFrontmatterSchema as j, CLAUDECODE_SKILLS_DIR_PATH as k, ALL_FEATURES_WITH_WILDCARD as kt, SubagentsProcessor as l, RULESYNC_CONFIG_RELATIVE_FILE_PATH as lt, RulesyncSkill as m, RULESYNC_IGNORE_RELATIVE_FILE_PATH as mt, checkRulesyncDirExists as n, ALL_TOOL_TARGETS as nt, RulesProcessor as o, RULESYNC_AIIGNORE_FILE_NAME as ot, getLocalSkillDirNames as p, RULESYNC_HOOKS_RELATIVE_FILE_PATH as pt, getHomeDirectory as q, generate as r, ALL_TOOL_TARGETS_WITH_WILDCARD as rt, RulesyncRule as s, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as st, importFromTool as t, writeFileContent as tt, RulesyncSubagent as u, RULESYNC_CONFIG_SCHEMA_URL as ut, McpProcessor as v, RULESYNC_MCP_SCHEMA_URL as vt, CommandsProcessor as w, RULESYNC_SKILLS_RELATIVE_DIR_PATH as wt, RulesyncIgnore as x, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as xt, RulesyncMcp as y, RULESYNC_OVERVIEW_FILE_NAME as yt, ErrorCodes as z };
 
-//# sourceMappingURL=import-DC9T1JlQ.js.map
+//# sourceMappingURL=import-Dioh9ca8.js.map