rulesync 16.34.1 → 16.35.0

package/dist/{import-BJsTd50i.js → import-DxRza3o_.js}

@@ -457,6 +457,22 @@ const RULESYNC_PERMISSIONS_FILE_NAME = "permissions.jsonc";
 const RULESYNC_MCP_LEGACY_FILE_NAME = "mcp.json";
 const RULESYNC_HOOKS_LEGACY_FILE_NAME = "hooks.json";
 const RULESYNC_PERMISSIONS_LEGACY_FILE_NAME = "permissions.json";
+const RULESYNC_MCP_DEPRECATED_DOTFILE_NAME = ".mcp.json";
+const FEATURE_SOURCE_TREE_ENTRIES = {
+	rules: [RULES_FEATURE_SUBDIR],
+	commands: [COMMANDS_FEATURE_SUBDIR],
+	subagents: [SUBAGENTS_FEATURE_SUBDIR],
+	skills: [SKILLS_FEATURE_SUBDIR],
+	checks: [CHECKS_FEATURE_SUBDIR],
+	ignore: [RULESYNC_AIIGNORE_FILE_NAME],
+	mcp: [
+		RULESYNC_MCP_FILE_NAME,
+		RULESYNC_MCP_LEGACY_FILE_NAME,
+		RULESYNC_MCP_DEPRECATED_DOTFILE_NAME
+	],
+	hooks: [RULESYNC_HOOKS_FILE_NAME, RULESYNC_HOOKS_LEGACY_FILE_NAME],
+	permissions: [RULESYNC_PERMISSIONS_FILE_NAME, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME]
+};
 const RULESYNC_CONFIG_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/config-schema.json";
 const RULESYNC_MCP_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/mcp-schema.json";
 const RULESYNC_PERMISSIONS_SCHEMA_URL = "https://github.com/dyoshikawa/rulesync/releases/latest/download/permissions-schema.json";
@@ -499,6 +515,7 @@ const rulesProcessorToolTargetTuple = [
 	"musecode",
 	"opencode",
 	"pi",
+	"pool",
 	"qwencode",
 	"reasonix",
 	"replit",
@@ -512,7 +529,6 @@ const rulesProcessorToolTargetTuple = [
 	"zcode",
 	"zed",
 	"zoocode",
-	"pool",
 	"dsh"
 ];
 const ignoreProcessorToolTargetTuple = [
@@ -4075,6 +4091,10 @@ const HookDefinitionSchema = z.looseObject({
 	model: z.optional(safeString),
 	args: z.optional(z.array(safeString)),
 	metadata: z.optional(z.looseObject({})),
+	source: z.optional(z.looseObject({
+		source: safeString,
+		ref: z.optional(safeString)
+	})),
 	if: z.optional(safeString),
 	commandWindows: z.optional(safeString),
 	additionalContextLimit: z.optional(z.int().check(nonnegative())),
@@ -4835,10 +4855,12 @@ const ZCODE_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONIC
 *
 * Bob reads `hooks` from `.bob/settings.json` (project) and
 * `~/.bob/settings/settings.json` (user) in the Claude-Code shape and fires
-* five events: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse and
-* Stop. Only `command` hooks exist, and `matcher` (a regex over the tool
-* name) applies to the two tool events.
+* seven events: SessionStart, UserPromptSubmit, PreToolUse, PostToolUse,
+* PreCompact, PostCompact (both added by Bob Shell 2.0.3) and Stop. Handlers
+* are `command` or `https` hooks, and `matcher` (a regex over the tool name)
+* applies to the two tool events.
 *
+* @see https://bob.ibm.com/docs/shell/configuration/lifecycle-hooks
 * @see https://bob.ibm.com/docs/ide/configuration/lifecycle-hooks
 */
 const BOB_HOOK_EVENTS = [
@@ -4846,6 +4868,8 @@ const BOB_HOOK_EVENTS = [
 	"beforeSubmitPrompt",
 	"preToolUse",
 	"postToolUse",
+	"preCompact",
+	"postCompact",
 	"stop"
 ];
 const CANONICAL_TO_BOB_EVENT_NAMES = {
@@ -4853,6 +4877,8 @@ const CANONICAL_TO_BOB_EVENT_NAMES = {
 	beforeSubmitPrompt: "UserPromptSubmit",
 	preToolUse: "PreToolUse",
 	postToolUse: "PostToolUse",
+	preCompact: "PreCompact",
+	postCompact: "PostCompact",
 	stop: "Stop"
 };
 const BOB_TO_CANONICAL_EVENT_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_BOB_EVENT_NAMES).map(([k, v]) => [v, k]));
@@ -6356,7 +6382,7 @@ var RulesyncMcp = class RulesyncMcp extends RulesyncFile {
 				relativeFilePath: RULESYNC_MCP_LEGACY_FILE_NAME
 			}, {
 				relativeDirPath: RULESYNC_RELATIVE_DIR_PATH,
-				relativeFilePath: ".mcp.json"
+				relativeFilePath: RULESYNC_MCP_DEPRECATED_DOTFILE_NAME
 			}]
 		};
 	}
@@ -7264,13 +7290,30 @@ const DeepagentsExtensionsOverrideSchema = z.looseObject({
 	]))
 });
 /**
+* The `[mcp]` table of `~/.deepagents/config.toml`, where dcode keeps its
+* per-server trust for the MCP servers a project's `.mcp.json` /
+* `.deepagents/.mcp.json` declares. dcode reads these lists from the user-level
+* file only — never from a project file — which is exactly why the global
+* permissions adapter is the place to author them.
+*
+* `disabled_project_servers` names project MCP servers dcode always rejects;
+* a rejection wins over any approval or trust. The sibling
+* `enabled_project_server_approvals` is the fingerprint-bound approval store
+* the interactive prompt fills in, and `enabled_project_servers` is a
+* deprecated flat allowlist dcode ignores, so neither has a key here.
+*
+* @see https://docs.langchain.com/oss/deepagents/code/configuration
+*/
+const DeepagentsMcpOverrideSchema = z.looseObject({ disabled_project_servers: z.optional(z.array(z.string())) });
+/**
 * The `[shell].allow_list` array itself is rulesync-owned, driven by the
 * shared `permission.bash` block, so it has no key here.
 */
 const DeepagentsPermissionsOverrideSchema = z.looseObject({
 	permission: z.optional(ToolScopedPermissionSchema),
 	startup: z.optional(DeepagentsStartupOverrideSchema),
-	extensions: z.optional(DeepagentsExtensionsOverrideSchema)
+	extensions: z.optional(DeepagentsExtensionsOverrideSchema),
+	mcp: z.optional(DeepagentsMcpOverrideSchema)
 });
 /**
 * The actions Junie's allowlist accepts. Verified against the shipped Junie
@@ -9584,7 +9627,13 @@ const RulesyncSkillFrontmatterSchema = z.looseObject({
 		"user-invocable": z.optional(z.boolean()),
 		"allowed-tools": z.optional(z.union([z.string(), z.array(z.string())]))
 	})),
-	commandcode: z.optional(z.looseObject({})),
+	commandcode: z.optional(z.looseObject({
+		license: z.optional(z.string()),
+		compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
+		metadata: z.optional(z.looseObject({})),
+		"disable-model-invocation": z.optional(z.boolean()),
+		"user-invocable": z.optional(z.boolean())
+	})),
 	cortexcode: z.optional(z.looseObject({})),
 	continue: z.optional(z.looseObject({})),
 	tabnine: z.optional(z.looseObject({})),
@@ -9828,7 +9877,7 @@ async function getLocalSkillDirNames(sourceTree) {
 *
 * The rulesync skill frontmatter exposes a root-level `disable-model-invocation`
 * default that applies to every tool supporting the flag (claudecode, copilot,
-* copilotcli, crush, cursor, zed, pi, qwencode, grokcli, factorydroid, dsh). Each tool's own section may override that
+* copilotcli, crush, cursor, zed, pi, qwencode, grokcli, factorydroid, dsh, commandcode). Each tool's own section may override that
 * default with a per-target value. A defined section value (including `false`)
 * always wins over the root default.
 *
@@ -9847,7 +9896,7 @@ function resolveDisableModelInvocation({ rootFrontmatter, section }) {
 *
 * The rulesync skill frontmatter exposes a root-level `user-invocable` default
 * that applies to every tool supporting the flag (claudecode, copilot,
-* copilotcli, crush, cursor, qwencode, vibe, grokcli, factorydroid, dsh). Each tool's own section may override that default with a
+* copilotcli, crush, cursor, qwencode, vibe, grokcli, factorydroid, dsh, commandcode). Each tool's own section may override that default with a
 * per-target value. A defined section value (including `false`) always wins
 * over the root default.
 *
@@ -15415,6 +15464,7 @@ var CodexcliCommand = class CodexcliCommand extends ToolCommand {
 const COMMANDCODE_DIR = ".commandcode";
 const COMMANDCODE_RULE_FILE_NAME = "AGENTS.md";
 const COMMANDCODE_SETTINGS_FILE_NAME = "settings.json";
+const COMMANDCODE_SETTINGS_LOCAL_FILE_NAME = "settings.local.json";
 const COMMANDCODE_PROJECT_MCP_FILE_NAME = ".mcp.json";
 const COMMANDCODE_GLOBAL_MCP_FILE_NAME = "mcp.json";
 const COMMANDCODE_COMMANDS_DIR_PATH = join(COMMANDCODE_DIR, "commands");
@@ -20629,6 +20679,18 @@ function isToolMatcherEntry(x) {
 	return true;
 }
 /**
+* Convert a canonical `timeout` (seconds) into the tool's unit.
+*/
+function emitTimeout({ timeout, converterConfig }) {
+	return converterConfig.timeoutUnit === "milliseconds" && Number.isFinite(timeout) ? Math.round(timeout * 1e3) : timeout;
+}
+/**
+* Convert a tool `timeout` back into the canonical unit (seconds).
+*/
+function importTimeout({ timeout, converterConfig }) {
+	return converterConfig.timeoutUnit === "milliseconds" && Number.isFinite(timeout) ? timeout / 1e3 : timeout;
+}
+/**
 * Filter the shared canonical hooks to the supported events and merge tool overrides on top.
 */
 function buildEffectiveHooks$1({ config, toolOverrideHooks, supportedEvents }) {
@@ -20769,6 +20831,7 @@ const isEmittableString = ({ value }) => isNonEmptyString(value);
 const isEmittableArray = ({ value }) => isStringArray$1(value);
 const isEmittableRecord = ({ value }) => isSafeStringRecord(value);
 const isImportableArray = ({ value }) => isSafeStringArray(value);
+const isEmittableObject = ({ value }) => isPlainObject$1(value);
 /**
 * The canonical schema of one hook field, looked up by name. Read off the
 * schema's own shape rather than by parsing a one-field object, so a `canonical`
@@ -20803,11 +20866,17 @@ const isImportableNumber = ({ value, canonical }) => Number.isFinite(value) && s
 	value,
 	canonical
 });
+const isImportableObject = ({ value, canonical }) => isPlainObject$1(value) && satisfiesCanonicalField({
+	value,
+	canonical
+});
 /**
 * Say which rule the value broke, so the warning names the actual constraint
 * rather than asserting a canonical rejection that may not be the reason. A
 * closed enum lists its members; a rule carrying its own message (the
-* control-character check behind `safeString`) reuses it.
+* control-character check behind `safeString`) reuses it. An object field
+* names the offending key, since zod's generic "Invalid input" would not tell
+* the reader which key is missing or malformed.
 */
 function describeScalarConstraint({ canonical, value }) {
 	const schema = canonicalFieldSchema(canonical);
@@ -20815,13 +20884,22 @@ function describeScalarConstraint({ canonical, value }) {
 	if (result === void 0 || result.success) return `it is not a value this field carries through.`;
 	const issue = result.error.issues[0];
 	if (issue === void 0) return `it is not a value the canonical "${canonical}" field accepts.`;
-	return `it does not satisfy the canonical "${canonical}" field: ${issue.message}.`;
+	return `it does not satisfy the canonical "${canonical}" field${issue.path.length > 0 ? ` at ${quoteValueForWarning(issue.path.map(String).join("."))}` : ""}: ${issue.message}.`;
 }
 const describeInvalidScalar = ({ tool, canonical, value }) => `Dropping "${tool}" (${quoteValueForWarning(value)}) while importing a hook: ${describeScalarConstraint({
 	canonical,
 	value
 })} Importing it would fail validation on the next run.`;
 const describeInvalidArray = ({ tool }) => `Dropping "${tool}" while importing a hook: it must be a list of strings without newline, carriage return or NUL characters.`;
+/**
+* An object is quoted by its offending key rather than its value: the payload
+* can be arbitrarily large, and the missing or malformed key is what the
+* reader needs to fix.
+*/
+const describeInvalidObject = ({ tool, canonical, value }) => isPlainObject$1(value) ? `Dropping "${tool}" while importing a hook: ${describeScalarConstraint({
+	canonical,
+	value
+})} Importing it would fail validation on the next run.` : `Dropping "${tool}" while importing a hook: it must be an object.`;
 const describeInvalidRecord = ({ tool }) => `Dropping "${tool}" while importing a hook: it must be a map of strings whose keys are non-empty and free of "=", and whose keys and values carry no newline, carriage return or NUL characters.`;
 /**
 * Check a value against the shape its field documents. A string field also
@@ -20927,6 +21005,14 @@ function emitAllPassthroughFields({ def, hookType, eventName, converterConfig, w
 			fields: converterConfig.recordPassthroughFields ?? [],
 			isValid: isEmittableRecord,
 			warn
+		}),
+		...emitPassthroughFields({
+			def,
+			hookType,
+			eventName,
+			fields: converterConfig.objectPassthroughFields ?? [],
+			isValid: isEmittableObject,
+			warn
 		})
 	};
 }
@@ -20950,9 +21036,12 @@ function buildToolHooks({ defs, eventName, converterConfig, warn }) {
 				converterConfig,
 				warn
 			}),
-			type: hookType,
+			type: converterConfig.hookTypeNames?.[hookType] ?? hookType,
 			...command !== void 0 && command !== null && { command },
-			...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
+			...def.timeout !== void 0 && def.timeout !== null && { timeout: emitTimeout({
+				timeout: def.timeout,
+				converterConfig
+			}) },
 			...def.prompt !== void 0 && def.prompt !== null && { prompt: def.prompt },
 			...emitTypePayloadFields({
 				def,
@@ -21074,6 +21163,20 @@ const IMPORTED_HOOK_TYPES = /* @__PURE__ */ new Set([
 function isImportedHookType(value) {
 	return typeof value === "string" && IMPORTED_HOOK_TYPES.has(value);
 }
+/**
+* The canonical hook type a tool-side `type` value denotes: the tool's own
+* spelling from {@link ToolHooksConverterConfig.hookTypeNames} when it has
+* one, otherwise the value itself when it is a canonical type, and `command`
+* for anything else (the same coercion as before the renames existed).
+*/
+function resolveImportedHookType({ value, converterConfig }) {
+	const names = converterConfig.hookTypeNames;
+	if (names !== void 0 && typeof value === "string") {
+		for (const [canonical, tool] of Object.entries(names)) if (tool === value) return canonical;
+		if (Object.hasOwn(names, value)) return "command";
+	}
+	return isImportedHookType(value) ? value : "command";
+}
 function isStringRecord(value) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
 	return Object.values(value).every((v) => typeof v === "string");
@@ -21239,6 +21342,14 @@ function importAllPassthroughFields({ h, hookType, converterConfig, warn }) {
 			isValid: isEmittableRecord,
 			describeInvalid: describeInvalidRecord,
 			warn
+		}),
+		...importPassthroughFields({
+			h,
+			hookType,
+			fields: converterConfig.objectPassthroughFields ?? [],
+			isValid: isImportableObject,
+			describeInvalid: describeInvalidObject,
+			warn
 		})
 	};
 }
@@ -21246,7 +21357,10 @@ function importAllPassthroughFields({ h, hookType, converterConfig, warn }) {
 * Convert a single tool hook record into a canonical hook definition.
 */
 function toolHookToCanonical({ h, rawEntry, converterConfig, warn }) {
-	const hookType = isImportedHookType(h.type) ? h.type : "command";
+	const hookType = resolveImportedHookType({
+		value: h.type,
+		converterConfig
+	});
 	const command = importCanonicalString({
 		value: stripCommandPrefix({
 			command: h.command,
@@ -21255,7 +21369,10 @@ function toolHookToCanonical({ h, rawEntry, converterConfig, warn }) {
 		canonical: "command",
 		warn
 	});
-	const timeout = typeof h.timeout === "number" ? h.timeout : void 0;
+	const timeout = typeof h.timeout === "number" ? importTimeout({
+		timeout: h.timeout,
+		converterConfig
+	}) : void 0;
 	const prompt = importCanonicalString({
 		value: h.prompt,
 		canonical: "prompt",
@@ -21388,7 +21505,10 @@ function toolMatcherEntryToCanonical({ rawEntry, converterConfig, warn }) {
 		const skipReason = describeHookSkipReason({
 			h,
 			rawEntry,
-			hookType: isImportedHookType(h.type) ? h.type : "command",
+			hookType: resolveImportedHookType({
+				value: h.type,
+				converterConfig
+			}),
 			converterConfig
 		});
 		if (skipReason !== void 0) {
@@ -21873,6 +21993,7 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 		"beforeSubmitPrompt"
 	]),
 	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	timeoutUnit: "milliseconds",
 	arrayPassthroughFields: [{
 		canonical: "args",
 		tool: "args"
@@ -22471,9 +22592,12 @@ const BOB_SPEC = {
 		noMatcherEvents: /* @__PURE__ */ new Set([
 			"sessionStart",
 			"beforeSubmitPrompt",
+			"preCompact",
+			"postCompact",
 			"stop"
 		]),
-		supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+		supportedHookTypes: /* @__PURE__ */ new Set(["command", "http"]),
+		hookTypeNames: { http: "https" },
 		wildcardMatcherMeansAll: true
 	}
 };
@@ -22484,10 +22608,13 @@ const BOB_SPEC = {
 * `<project>/.bob/settings.json` (project scope) and
 * `~/.bob/settings/settings.json` (user scope) — in the Claude-Code shape:
 * `{ "<Event>": [{ "matcher"?: "<regex>", "hooks": [{ "type": "command",
-* "command": "...", "timeout"?: <seconds> }] }] }`. The file also holds
-* settings rulesync does not own, so generation merges the `hooks` key into it
-* (see `SHARED_CONFIG_OWNERSHIP`) instead of overwriting the file.
+* "command": "...", "timeout"?: <seconds> }] }] }`, where a handler may
+* instead be `{ "type": "https", "url": "...", "timeout"?: <seconds> }`. The
+* file also holds settings rulesync does not own, so generation merges the
+* `hooks` key into it (see `SHARED_CONFIG_OWNERSHIP`) instead of overwriting
+* the file.
 *
+* @see https://bob.ibm.com/docs/shell/configuration/lifecycle-hooks
 * @see https://bob.ibm.com/docs/ide/configuration/lifecycle-hooks
 */
 var BobHooks = class extends SettingsJsonHooks {
@@ -23917,6 +24044,11 @@ const CORTEXCODE_SPEC = {
 		booleanPassthroughFields: [{
 			canonical: "enabled",
 			tool: "enabled"
+		}],
+		objectPassthroughFields: [{
+			canonical: "source",
+			tool: "source",
+			commandOnly: true
 		}]
 	}
 };
@@ -23927,8 +24059,9 @@ const CORTEXCODE_SPEC = {
 * (project scope) and of the dedicated `~/.snowflake/cortex/hooks.json` (user
 * scope), both in the Claude-Code shape: `{ "<Event>": [{ "matcher"?:
 * "<regex>", "hooks": [{ "type": "command" | "prompt", ..., "timeout"?:
-* <seconds>, "enabled"?: <boolean> }] }] }`. The project file also holds
-* settings rulesync does not own, so generation merges the `hooks` key into
+* <seconds>, "enabled"?: <boolean>, "source"?: { "source", "ref"? } }] }] }`.
+* The project file also holds settings rulesync does not own, so generation
+* merges the `hooks` key into
 * either file (see `SHARED_CONFIG_OWNERSHIP`) instead of overwriting it, and
 * neither file is removed wholesale (hooks.json sits in the CLI-owned
 * `~/.snowflake/cortex/` tree).
@@ -28574,7 +28707,7 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: BOB_HOOK_EVENTS,
-		supportedHookTypes: ["command"],
+		supportedHookTypes: ["command", "http"],
 		supportsMatcher: true,
 		matcherEvents: ["preToolUse", "postToolUse"]
 	}],
@@ -31388,6 +31521,50 @@ function parseBobMcpConfig({ fileContent, relativePath }) {
 /** The `type` Bob IDE writes for a streamable HTTP server. */
 const BOB_STREAMABLE_HTTP_TYPE = "streamable-http";
 /**
+* The OAuth keys Bob reads flat on a server entry, next to `oauth` (a
+* boolean: `true` forces the flow on, `false` off, absent lets Bob detect it).
+* The canonical shape is Claude Code's nested `oauth: { clientId, ... }`
+* object, so the two are translated in both directions.
+* @see https://bob.ibm.com/docs/ide/configuration/mcp/mcp-oauth
+*/
+const BOB_FLAT_OAUTH_KEYS = [
+	"clientId",
+	"clientSecret",
+	"scope"
+];
+/**
+* Flatten the canonical `oauth` object onto a Bob server entry: `oauth: true`
+* plus the string-valued keys Bob documents. A flat key the server already
+* carries (authored in Bob's own spelling) is kept over the nested one. Other
+* nested keys (`callbackPort`, `redirectUri`) have no Bob counterpart and are
+* dropped rather than nested under a key Bob reads as a boolean.
+*/
+function flattenOauthForBob({ oauth, converted }) {
+	converted.oauth = true;
+	for (const key of BOB_FLAT_OAUTH_KEYS) {
+		const value = oauth[key];
+		if (typeof value === "string" && converted[key] === void 0) converted[key] = value;
+	}
+}
+/**
+* Reverse of {@link flattenOauthForBob}: gather Bob's flat OAuth keys into the
+* canonical `oauth` object. `oauth: true` always folds (even with no keys, so
+* the explicit enable survives the round-trip as an empty object); with no
+* `oauth` key at all the fold happens only when a flat key is present, since
+* that is what makes the entry an OAuth one for Bob; `oauth: false` and
+* anything else leave the entry as it is.
+*/
+function nestOauthFromBob(converted) {
+	const flat = BOB_FLAT_OAUTH_KEYS.filter((key) => typeof converted[key] === "string");
+	if (!(converted.oauth === true || converted.oauth === void 0 && flat.length > 0)) return;
+	const oauth = {};
+	for (const key of flat) {
+		oauth[key] = converted[key];
+		delete converted[key];
+	}
+	converted.oauth = oauth;
+}
+/**
 * The remote transport Bob IDE reads a server as, spelled the way it writes
 * it: `streamable-http` needs an explicit `type`, while SSE (legacy) is a bare
 * `url` with no `type`. `http` is the canonical rulesync alias for streamable
@@ -31410,7 +31587,9 @@ function asBobRemoteType(stated, url) {
 * `headers`, `timeout`, `alwaysAllow` and `disabled` pass through, as Bob
 * documents all of them, with prototype-pollution keys dropped at every
 * nesting level (Bob spreads `env` and `headers` into the process environment
-* and the HTTP requests).
+* and the HTTP requests). The canonical `oauth` object is flattened onto the
+* entry as `oauth: true` plus `clientId` / `clientSecret` / `scope`, the keys
+* Bob reads; a boolean `oauth` passes through as Bob's own on/off switch.
 *
 * Bob Shell documents the same file with an `httpURL` key instead of
 * `type` + `url` for streamable HTTP. rulesync writes the IDE spelling (the two
@@ -31476,10 +31655,16 @@ function convertToBobFormat(mcpServers, logger) {
 			converted.command = command;
 			if (args.length > 0) converted.args = args;
 		}
-		for (const [key, value] of Object.entries(rest)) {
+		const { oauth, ...passthrough } = rest;
+		for (const [key, value] of Object.entries(passthrough)) {
 			if (PROTOTYPE_POLLUTION_KEYS.has(key)) continue;
 			converted[key] = omitPrototypePollutionKeysDeep(value);
 		}
+		if (isRecord$1(oauth)) flattenOauthForBob({
+			oauth,
+			converted
+		});
+		else if (oauth !== void 0) converted.oauth = oauth;
 		result[serverName] = converted;
 	}
 	return result;
@@ -31489,9 +31674,10 @@ function convertToBobFormat(mcpServers, logger) {
 * (`type: "streamable-http"` + `url`) is already canonical and passes through;
 * the Bob Shell spelling `httpURL` becomes `url` with `type: "http"`; a bare
 * `url` is an SSE server in Bob, so it gains `type: "sse"` to keep that reading
-* on the next generate. Every other field passes through with its
-* prototype-pollution keys dropped at every nesting level, mirroring the
-* generate side's handling of `env` / `headers`.
+* on the next generate. Bob's flat OAuth keys are gathered back into the
+* canonical `oauth` object (see {@link nestOauthFromBob}). Every other field
+* passes through with its prototype-pollution keys dropped at every nesting
+* level, mirroring the generate side's handling of `env` / `headers`.
 */
 function convertFromBobFormat(mcpServers) {
 	if (!isMcpServers(mcpServers)) return {};
@@ -31512,6 +31698,7 @@ function convertFromBobFormat(mcpServers) {
 			converted.url = httpURL;
 			converted.type = "http";
 		} else if (typeof converted.url === "string" && converted.type === void 0) converted.type = "sse";
+		nestOauthFromBob(converted);
 		result[serverName] = converted;
 	}
 	return result;
@@ -32536,7 +32723,10 @@ function asContinueRemoteType(stated, url) {
 * file with a strict union — one server that matches neither shape (an
 * unknown transport, a non-string `env` value) makes Continue drop every
 * server in the file — so only the documented keys are emitted and anything
-* else (`timeout`, `oauth`, rulesync-only fields) is left out. `envFile` is
+* else is left out. The canonical keys a user would expect to take effect
+* (`cwd`, `timeout`, `oauth`) are dropped with a warning, since the JSON
+* schema has no place for them (the YAML block form does, but Rulesync writes
+* the JSON file); rulesync-only fields are dropped silently. `envFile` is
 * accepted by Continue's schema but ignored with a warning at load time, so
 * it is dropped here with a warning instead of being written as if it worked.
 *
@@ -32572,6 +32762,17 @@ function convertToContinueFormat(mcpServers, logger) {
 	}
 	return result;
 }
+/**
+* Warn for each canonical key Continue's JSON MCP schema cannot carry, so a
+* dropped `cwd`, `timeout` or `oauth` does not go unnoticed in a config that
+* otherwise looks complete.
+*/
+function warnUnsupportedContinueKeys({ serverName, serverConfig, keys, logger }) {
+	for (const key of keys) {
+		if (serverConfig[key] === void 0) continue;
+		logger?.warn(`Continue's MCP config has no "${key}" field, so the ${key} of server ${quoteValueForWarning(serverName)} was not written.`);
+	}
+}
 function convertRemoteServer({ serverName, serverConfig, logger }) {
 	const url = resolveRemoteMcpUrl(serverConfig);
 	if (!url) {
@@ -32599,6 +32800,12 @@ function convertRemoteServer({ serverName, serverConfig, logger }) {
 		url
 	};
 	if (isRecord$1(serverConfig.headers)) converted.headers = omitPrototypePollutionKeys(serverConfig.headers);
+	warnUnsupportedContinueKeys({
+		serverName,
+		serverConfig,
+		keys: ["timeout", "oauth"],
+		logger
+	});
 	return converted;
 }
 function convertStdioServer({ serverName, serverConfig, logger }) {
@@ -32619,6 +32826,12 @@ function convertStdioServer({ serverName, serverConfig, logger }) {
 	if (args.length > 0) converted.args = args;
 	if (isRecord$1(serverConfig.env)) converted.env = omitPrototypePollutionKeys(serverConfig.env);
 	if (typeof serverConfig.envFile === "string") logger?.warn(`Continue ignores "envFile" for MCP servers, so the envFile of server ${quoteValueForWarning(serverName)} was not written; put the variables in "env" instead.`);
+	warnUnsupportedContinueKeys({
+		serverName,
+		serverConfig,
+		keys: ["cwd", "timeout"],
+		logger
+	});
 	return converted;
 }
 /**
@@ -45117,6 +45330,27 @@ const DEEPAGENTS_EXTENSION_TRUST_POLICIES = [
 * @see https://github.com/langchain-ai/deepagents `config_manifest.py`
 */
 const DEEPAGENTS_EXTENSIONS_ENABLED_DEFAULT = true;
+/**
+* `[mcp]` holds dcode's per-server trust for the MCP servers a project's
+* `.mcp.json` / `.deepagents/.mcp.json` declares. `load_mcp_server_trust_lists`
+* reads it from the user-level `config.toml` only — never from a project file —
+* so the global adapter is the one place rulesync can author it.
+*/
+const MCP_TABLE_KEY = "mcp";
+/**
+* Keys lifted back into the override on import. `disabled_project_servers` is
+* the deny list: a name on it is always rejected, over any approval or trust.
+*/
+const DEEPAGENTS_MCP_KEYS = ["disabled_project_servers"];
+const MCP_DISABLED_PROJECT_SERVERS_KEY = "disabled_project_servers";
+/**
+* dcode's own store of the project servers the user approved at the prompt,
+* each bound to a repository or worktree and a definition fingerprint. It is
+* machine-local state and a way to pre-approve a project's servers, so a
+* repository's `.rulesync/permissions.jsonc` must not reach it: generate drops
+* the key here, and import never lifts it (`DEEPAGENTS_MCP_KEYS`).
+*/
+const MCP_APPROVALS_KEY = "enabled_project_server_approvals";
 const ALLOW_ALL_SENTINEL = "all";
 const RECOMMENDED_SENTINEL = "recommended";
 const GLOB_CHARACTERS_PATTERN = /[*?[\]]/;
@@ -45189,7 +45423,9 @@ const TRAILING_ARGUMENT_WILDCARD_PATTERN = /:\*$/;
 * lifted back into the override on import. The same override carries
 * `[extensions].enabled` and `[extensions].trust` (`ask` / `always` / `never`),
 * which decide whether the Python in a checked-out project's
-* `.deepagents/extensions/` is imported into the agent process.
+* `.deepagents/extensions/` is imported into the agent process, and
+* `[mcp].disabled_project_servers`, the names of project MCP servers dcode
+* always rejects.
 *
 * On **import** the allowlist comes back as `bash` `allow` rules named by the
 * executable — skipping any entry dcode could not match in the first place, so
@@ -45287,17 +45523,9 @@ var DeepagentsPermissions = class DeepagentsPermissions extends ToolPermissions
 			if (Object.keys(shell).length > 0) settings[SHELL_TABLE_KEY] = shell;
 			else delete settings[SHELL_TABLE_KEY];
 		}
-		const startupOverride = config.deepagents?.startup;
-		if (isPlainObject$1(startupOverride) && Object.keys(startupOverride).length > 0) mergeStartupOverride({
-			settings,
-			startupOverride,
-			filePath,
-			logger
-		});
-		const extensionsOverride = config.deepagents?.extensions;
-		if (isPlainObject$1(extensionsOverride) && Object.keys(extensionsOverride).length > 0) mergeExtensionsOverride({
+		mergeDeepagentsOverrides({
 			settings,
-			extensionsOverride,
+			override: config.deepagents,
 			filePath,
 			logger
 		});
@@ -45329,10 +45557,15 @@ var DeepagentsPermissions = class DeepagentsPermissions extends ToolPermissions
 			extensions: isPlainObject$1(settings[EXTENSIONS_TABLE_KEY]) ? settings[EXTENSIONS_TABLE_KEY] : {},
 			selfPath
 		});
+		const mcpOverride = liftMcpOverride({
+			mcp: isPlainObject$1(settings[MCP_TABLE_KEY]) ? settings[MCP_TABLE_KEY] : {},
+			selfPath
+		});
 		const result = { ...config };
 		const deepagents = {};
 		if (Object.keys(startupOverride).length > 0) deepagents.startup = startupOverride;
 		if (Object.keys(extensionsOverride).length > 0) deepagents.extensions = extensionsOverride;
+		if (Object.keys(mcpOverride).length > 0) deepagents.mcp = mcpOverride;
 		if (Object.keys(deepagents).length > 0) result.deepagents = deepagents;
 		return RulesyncPermissions.fromImportedFileContent({
 			outputRoot: getDeepagentsRulesyncOutputRoot({
@@ -45440,7 +45673,7 @@ function warnAboutUnwrittenBashRules({ allowAll, requestedAllowAll, askPatterns,
 * read — a wrapper rather than the bare value, so a legitimately falsy setting
 * is not mistaken for a rejection.
 */
-function liftOverrideTable({ table, tableKey, keys, normalize, selfPath }) {
+function liftOverrideTable({ table, tableKey, keys, normalize, selfPath, describeRejection = `deepagents-cli falls back to its own default for a '[${tableKey}]' value it cannot read` }) {
 	const override = {};
 	const rejected = [];
 	for (const key of keys) {
@@ -45453,7 +45686,7 @@ function liftOverrideTable({ table, tableKey, keys, normalize, selfPath }) {
 		if (normalized) override[key] = normalized.value;
 		else rejected.push(`${key} = ${JSON.stringify(value)}`);
 	}
-	if (rejected.length > 0) warnWithFallback(void 0, `deepagents-cli falls back to its own default for a '[${tableKey}]' value it cannot read, so ${rejected.join(", ")} in ${selfPath} ${rejected.length === 1 ? "was" : "were"} not imported.`);
+	if (rejected.length > 0) warnWithFallback(void 0, `${describeRejection}, so ${rejected.join(", ")} in ${selfPath} ${rejected.length === 1 ? "was" : "were"} not imported.`);
 	return override;
 }
 /**
@@ -45501,6 +45734,37 @@ function liftExtensionsOverride({ extensions, selfPath }) {
 	});
 }
 /**
+* Read a `[mcp]` name list the way `_toml_str_list` reads it: a bare string
+* is split on commas, names are trimmed and empty ones dropped, and a
+* non-string element of a list is dropped while the names around it survive.
+* Anything else (a number, a table, a bool) is a value dcode cannot read as
+* names at all, so `null` says to leave it behind.
+*/
+function readMcpServerNames(value) {
+	if (typeof value === "string") return value.split(",").map((name) => name.trim()).filter((name) => name.length > 0);
+	if (!Array.isArray(value)) return null;
+	return value.filter((name) => typeof name === "string").map((name) => name.trim()).filter((name) => name.length > 0);
+}
+/**
+* Lift the `[mcp]` keys rulesync models back into the `deepagents` override.
+* The deny list comes back as the array dcode resolves it to, so the
+* comma-separated string form it also accepts does not survive as one bogus
+* name in a permissions file the canonical schema types as `string[]`.
+*/
+function liftMcpOverride({ mcp, selfPath }) {
+	return liftOverrideTable({
+		table: mcp,
+		tableKey: MCP_TABLE_KEY,
+		keys: DEEPAGENTS_MCP_KEYS,
+		normalize: ({ value }) => {
+			const names = readMcpServerNames(value);
+			return names ? { value: names } : null;
+		},
+		selfPath,
+		describeRejection: `deepagents-cli treats a '[${MCP_TABLE_KEY}]' value it cannot read as a broken trust policy and rejects every project MCP server until it is fixed`
+	});
+}
+/**
 * Merge one block of the `deepagents` override into its `config.toml` table,
 * preserving every other key of that table. A table that is not a table at all
 * is something rulesync did not write and cannot merge into, so it is left
@@ -45549,6 +45813,38 @@ function warnAboutUncheckedKeys({ tableKey, knownKeys, writtenKeys, filePath, lo
 	if (unknownKeys.length === 0) return;
 	warnWithFallback(logger, `The deepagents ${tableKey} override wrote ${unknownKeys.join(", ")} into ${filePath} unchecked — rulesync does not know what those keys grant, and that file is your global deepagents-cli config.`);
 }
+/** An override block with something in it to write. */
+function isSet(block) {
+	return isPlainObject$1(block) && Object.keys(block).length > 0;
+}
+/**
+* Merge each block of the `deepagents` override into its `config.toml` table.
+* A block that is absent, not a table, or empty has nothing to write and is
+* skipped without touching the table it would have gone into.
+*/
+function mergeDeepagentsOverrides({ settings, override, filePath, logger }) {
+	const startupOverride = override?.startup;
+	if (isSet(startupOverride)) mergeStartupOverride({
+		settings,
+		startupOverride,
+		filePath,
+		logger
+	});
+	const extensionsOverride = override?.extensions;
+	if (isSet(extensionsOverride)) mergeExtensionsOverride({
+		settings,
+		extensionsOverride,
+		filePath,
+		logger
+	});
+	const mcpOverride = override?.mcp;
+	if (isSet(mcpOverride)) mergeMcpOverride({
+		settings,
+		mcpOverride,
+		filePath,
+		logger
+	});
+}
 /**
 * Merge the `deepagents.startup` override into `[startup]`.
 */
@@ -45582,6 +45878,40 @@ function mergeExtensionsOverride({ settings, extensionsOverride, filePath, logge
 	});
 }
 /**
+* Merge the `deepagents.mcp` override into `[mcp]`. The approval store is
+* dropped (see `MCP_APPROVALS_KEY`); the deprecated flat
+* `enabled_project_servers` is not modeled but passes through like any other
+* unknown key, named by the unchecked-key warning — dcode ignores it anyway.
+*/
+function mergeMcpOverride({ settings, mcpOverride, filePath, logger }) {
+	mergeOverrideTable({
+		settings,
+		tableKey: MCP_TABLE_KEY,
+		override: mcpOverride,
+		knownKeys: DEEPAGENTS_MCP_KEYS,
+		isDroppedKey: (key) => key === MCP_APPROVALS_KEY,
+		warnAboutRelaxations: warnAboutMcpRelaxations,
+		filePath,
+		logger
+	});
+}
+/**
+* Warn when the `deepagents` mcp override re-enables project MCP servers the
+* machine's global config had rejected. The deny list is written as a whole,
+* so a shorter list from a repository's `.rulesync/permissions.jsonc` would
+* otherwise silently lift a rejection the user had put in place — the very
+* fail-open dcode's own env merge refuses to allow.
+*/
+function warnAboutMcpRelaxations({ override, previous, filePath, logger }) {
+	if (override[MCP_APPROVALS_KEY] !== void 0) warnWithFallback(logger, `The deepagents mcp override's '${MCP_APPROVALS_KEY}' was not written to ${filePath}: dcode builds that approval store itself from the project MCP servers you accept at launch, so a permissions file cannot pre-approve them.`);
+	const written = override[MCP_DISABLED_PROJECT_SERVERS_KEY];
+	if (written === void 0 || written === null) return;
+	const kept = new Set(readMcpServerNames(written) ?? []);
+	const reEnabled = (readMcpServerNames(previous[MCP_DISABLED_PROJECT_SERVERS_KEY]) ?? []).filter((name) => !kept.has(name));
+	if (reEnabled.length === 0) return;
+	warnWithFallback(logger, `The deepagents mcp override removed ${reEnabled.map((name) => JSON.stringify(name)).join(", ")} from [${MCP_TABLE_KEY}].${MCP_DISABLED_PROJECT_SERVERS_KEY} in ${filePath}, which is your global deepagents-cli config: dcode no longer rejects ${reEnabled.length === 1 ? "that project MCP server" : "those project MCP servers"} outright, for every project on this machine, not just this one.`);
+}
+/**
 * Name the value an override key replaces, so a setting the user had turned
 * down is visible as such rather than reported as a bare new value.
 */
@@ -57334,7 +57664,12 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 //#region src/features/skills/commandcode-skill.ts
 const CommandcodeSkillFrontmatterSchema = z.looseObject({
 	name: z.string(),
-	description: z.string()
+	description: z.string(),
+	license: z.optional(z.string()),
+	compatibility: z.optional(z.union([z.string(), z.looseObject({})])),
+	metadata: z.optional(z.looseObject({})),
+	"disable-model-invocation": z.optional(z.boolean()),
+	"user-invocable": z.optional(z.boolean())
 });
 /**
 * Represents a Command Code skill directory.
@@ -57417,10 +57752,35 @@ var CommandcodeSkill = class CommandcodeSkill extends ToolSkill {
 		const settablePaths = CommandcodeSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
 		const { name: _sectionName, description: _sectionDescription, ...commandcodeSection } = rulesyncFrontmatter.commandcode ?? {};
+		const license = resolveLicense({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: commandcodeSection
+		});
+		const compatibility = resolveCompatibility({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: commandcodeSection
+		});
+		const metadata = resolveMetadata({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: commandcodeSection
+		});
+		const disableModelInvocation = resolveDisableModelInvocation({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: commandcodeSection
+		});
+		const userInvocable = resolveUserInvocable({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: commandcodeSection
+		});
 		const commandcodeFrontmatter = {
 			...commandcodeSection,
 			name: rulesyncFrontmatter.name,
-			description: rulesyncFrontmatter.description
+			description: rulesyncFrontmatter.description,
+			...license !== void 0 && { license },
+			...compatibility !== void 0 && { compatibility },
+			...metadata !== void 0 && { metadata },
+			...disableModelInvocation !== void 0 && { "disable-model-invocation": disableModelInvocation },
+			...userInvocable !== void 0 && { "user-invocable": userInvocable }
 		};
 		return new CommandcodeSkill({
 			outputRoot,
@@ -64793,6 +65153,35 @@ const CommandcodeSubagentFrontmatterSchema = z.looseObject({
 	showOutput: z.optional(z.boolean())
 });
 /**
+* Names Command Code's built-in agents own. The loader runs the frontmatter
+* `name` (or the file stem when it has none) through `sanitizeAgentName`,
+* which rewrites every character outside `[a-zA-Z0-9_-]` to `_`, lowercases
+* it, and skips the file outright when the result is one of these
+* (`isReservedAgentName`) — with no message. Verified in the `command-code`
+* 1.54.2 bundle.
+* @see https://commandcode.ai/docs/agents
+*/
+const COMMANDCODE_RESERVED_AGENT_NAMES = /* @__PURE__ */ new Set([
+	"explore",
+	"plan",
+	"review",
+	"general"
+]);
+/** The name Command Code compares against its reserved list. */
+function toCommandcodeAgentName(name) {
+	return name.replace(/[^a-zA-Z0-9_-]/g, "_").toLowerCase();
+}
+/**
+* The subagent is still generated under the reserved name — the name is the
+* user's to change, and a rename here would make it diverge from the other
+* targets — but Command Code would drop it without a visible word, so say so
+* now (the same courtesy `VibeSkill` extends to its reserved skill names).
+*/
+function warnAboutReservedAgentName({ name, relativeFilePath, logger }) {
+	if (!COMMANDCODE_RESERVED_AGENT_NAMES.has(toCommandcodeAgentName(name))) return;
+	logger?.warn(`Command Code subagent ${relativeFilePath}: the name ${quoteValueForWarning(name)} is reserved for a Command Code built-in agent, so Command Code ignores a custom agent by that name when it loads agents. Rename the subagent for it to be available in Command Code.`);
+}
+/**
 * Command Code custom agent: a Markdown file with YAML frontmatter under
 * `.commandcode/agents/` (project) or `~/.commandcode/agents/` (user); the
 * body is the agent's system prompt.
@@ -64839,7 +65228,7 @@ var CommandcodeSubagent = class CommandcodeSubagent extends ToolSubagent {
 			validate: true
 		});
 	}
-	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false, logger }) {
 		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
 		const commandcodeSection = rulesyncFrontmatter.commandcode ?? {};
 		const commandcodeSubagentFrontmatter = {
@@ -64847,6 +65236,11 @@ var CommandcodeSubagent = class CommandcodeSubagent extends ToolSubagent {
 			description: rulesyncFrontmatter.description,
 			...commandcodeSection
 		};
+		warnAboutReservedAgentName({
+			name: commandcodeSubagentFrontmatter.name,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			logger
+		});
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, commandcodeSubagentFrontmatter, { avoidBlockScalars: true });
 		const paths = this.getSettablePaths({ global });
@@ -71219,8 +71613,12 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 	* | `false`          | none      | not supported; the rule is dropped  |
 	*
 	* The default being `true` is the opposite of Cursor, which the adapter was
-	* modeled on: `paths` alone scopes nothing, so a rule meant to be path
-	* triggered has to carry an explicit `alwaysApply: false` alongside it.
+	* modeled on. The shipped loader (`@tencent-ai/codebuddy-code` 2.151.0,
+	* `dist/codebuddy.js`) is looser than the table — it resolves
+	* `alwaysApply = fm.alwaysApply === true || (!hasPaths && fm.alwaysApply !== false)`,
+	* so `paths` without `alwaysApply` is already MANUAL — but the explicit
+	* `alwaysApply: false` is written anyway: it is correct under both readings
+	* and the documented one is what a reader of the file goes by.
 	*
 	* @see https://www.codebuddy.ai/docs/cli/memory
 	*/
@@ -71295,9 +71693,9 @@ var CodebuddyRule = class CodebuddyRule extends ToolRule {
 			});
 		}
 		const sourcePaths = normalizeCodebuddyPaths(this.frontmatter.paths) ?? [];
-		const isAlways = this.frontmatter.alwaysApply !== false;
+		const isAlways = this.frontmatter.alwaysApply === true || sourcePaths.length === 0 && this.frontmatter.alwaysApply !== false;
 		const globs = sourcePaths.length === 0 && isAlways ? ["**/*"] : sourcePaths;
-		const alwaysApply = this.frontmatter.alwaysApply ?? (sourcePaths.length > 0 ? true : void 0);
+		const alwaysApply = this.frontmatter.alwaysApply;
 		const rulesyncFrontmatter = {
 			targets,
 			root: false,
@@ -75988,6 +76386,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "fold"
 		}
 	}],
+	["pool", {
+		class: PoolRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold"
+		}
+	}],
 	["qwencode", {
 		class: QwencodeRule,
 		meta: {
@@ -76111,15 +76518,6 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "auto"
 		}
 	}],
-	["pool", {
-		class: PoolRule,
-		meta: {
-			extension: "md",
-			supportsGlobal: true,
-			ruleDiscoveryMode: "auto",
-			collisionPolicy: "fold"
-		}
-	}],
 	["dsh", {
 		class: DshRule,
 		meta: {
@@ -79305,6 +79703,6 @@ async function importChecksCore(params) {
 	return writtenCount;
 }
 //#endregion
-export { RulesyncCheck as $, writeFileContent as $t, CLAUDECODE_SKILLS_DIR_PATH as A, RULESYNC_SKILLS_RELATIVE_DIR_PATH as An, directoryExists as At, RulesyncSkill as B, truncateText as Bn, listSubdirectoryNames as Bt, ChecksProcessor as C, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as Cn, ErrorCodes as Ct, CLAUDECODE_LOCAL_RULE_FILE_NAME as D, RULESYNC_PERMISSIONS_SCHEMA_URL as Dn, assertWritablePathInsideRoot as Dt, CLAUDECODE_DIR as E, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as En, assertTreeContainsNoSymlinks as Et, AUGMENTCODE_DIR as F, parseCommaSeparatedList as Fn, isFileNotFoundError as Ft, RulesyncMcp as G, stripControlCharactersKeepingLineFeeds as Gn, removeDirectoryStrict as Gt, RulesyncRule as H, hasEnclosingMarkOutsideKeycap as Hn, readFileContent as Ht, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as I, ALL_FEATURES as In, isFileSystemError as It, getRulesyncSourceCandidates as J, removeTempDirectory as Jt, RulesyncIgnore as K, stripHiddenCharacters as Kn, removeFile as Kt, getLocalSkillDirNames as L, ALL_FEATURES_WITH_WILDCARD as Ln, isSymlink as Lt, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as M, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as Mn, fileExists as Mt, caseFoldIdentity as N, RULESYNC_USER_CONFIG_DIR_NAME as Nn, getFileSize as Nt, CLAUDECODE_MEMORIES_DIR_NAME as O, RULESYNC_RELATIVE_DIR_PATH as On, checkPathTraversal as Ot, groupSpellingsByCaseFoldedIdentity as P, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as Pn, getHomeDirectory as Pt, RulesyncCommandFrontmatterSchema as Q, writeFileBuffer as Qt, RulesyncSubagent as R, DEPRECATED_FEATURE_REPLACEMENTS as Rn, listDirectoryEntryNames as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_MCP_SCHEMA_URL as Sn, CLIError as St, CODEXCLI_DIR as T, RULESYNC_PERMISSIONS_LEGACY_FILE_NAME as Tn, assertDirectoryIfExists as Tt, RulesyncRuleFrontmatterSchema as U, quoteForLog as Un, readFileContentOrNull as Ut, RulesyncSkillFrontmatterSchema as V, hasDeceptiveHiddenCharacters as Vn, pathEscapesRoot as Vt, RulesyncPermissions as W, stripControlCharacters as Wn, removeDirectory as Wt, parseJsonc as X, runWithDirectoryRollback as Xt, resolveRulesyncSourceWritePath as Y, resolvePath as Yt, RulesyncCommand as Z, toPosixPath as Zt, IgnoreProcessor as _, RULESYNC_IGNORE_RELATIVE_FILE_PATH as _n, fallbackLogger as _t, getProcessorRegistryEntry as a, MAX_FILE_SIZE as an, ConfigResolver as at, CommandsProcessor as b, RULESYNC_MCP_LEGACY_FILE_NAME as bn, resetRunWarningState as bt, RulesProcessor as c, RULESYNC_CHECKS_RELATIVE_DIR_PATH as cn, CONFLICTING_TARGET_PAIRS as ct, CODEBUDDY_DIR as d, RULESYNC_CONFIG_SCHEMA_URL as dn, SourceEntrySchema as dt, ALL_TOOL_TARGETS as en, RulesyncCheckFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as fn, assertTargetsFeaturesExclusive as ft, McpProcessor as g, RULESYNC_HOOKS_RELATIVE_FILE_PATH as gn, WarningCollectingLogger as gt, shortenToWidth as h, RULESYNC_HOOKS_LEGACY_FILE_NAME as hn, JsonLogger as ht, inspectInputRoots as i, CURATED_RULES_FEATURE_SUBDIR as in, SKILL_FILE_NAME as it, FACTORYDROID_DIR as j, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as jn, ensureDir as jt, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as k, RULESYNC_RULES_RELATIVE_DIR_PATH as kn, createTempDirectory as kt, SubagentsProcessor as l, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as ln, ConfigFileSchema as lt, displayWidthOf as m, RULESYNC_HOOKS_FILE_NAME as mn, ConsoleLogger as mt, formatSourceLoadFailure as n, PACKAGING_TOOL_TARGETS as nn, loadYaml as nt, convertFromTool as o, RULESYNC_AIIGNORE_FILE_NAME as on, mergeInputRootConfigs as ot, ELLIPSIS_WIDTH as p, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as pn, findControlCharacter as pt, RulesyncHooks as q, removeFileStrict as qt, generate as r, ToolTargetSchema as rn, SHARED_USER_MANAGED_CONFIG_PATHS as rt, isPackagingToolTarget as s, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as sn, resolveEffectiveInputRoots as st, importFromTool as t, ALL_TOOL_TARGETS_WITH_WILDCARD as tn, stringifyFrontmatter as tt, SkillsProcessor as u, RULESYNC_CONFIG_RELATIVE_FILE_PATH as un, GITIGNORE_DESTINATION_KEY as ut, HooksProcessor as v, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as vn, warnOnConflictingFlags as vt, CODEXCLI_BASH_RULES_FILE_NAME as w, RULESYNC_PERMISSIONS_FILE_NAME as wn, applyFileMode as wt, QWENCODE_DIR as x, RULESYNC_MCP_RELATIVE_FILE_PATH as xn, withWarnOnceScope as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_MCP_FILE_NAME as yn, withFallbackLoggerTarget as yt, RulesyncSubagentFrontmatterSchema as z, formatError as zn, listFilePathsRecursively as zt };
+export { RulesyncCommand as $, toPosixPath as $t, CLAUDECODE_MEMORIES_DIR_NAME as A, RULESYNC_XDG_CONFIG_HOME_DEFAULT_DIR_NAME as An, checkPathTraversal as At, RulesyncSubagent as B, stripControlCharacters as Bn, listDirectoryEntryNames as Bt, COMMANDCODE_DIR as C, RULESYNC_PERMISSIONS_SCHEMA_URL as Cn, withWarnOnceScope as Ct, CODEXCLI_DIR as D, RULESYNC_SOURCES_LOCK_RELATIVE_FILE_PATH as Dn, assertDirectoryIfExists as Dt, CODEXCLI_BASH_RULES_FILE_NAME as E, RULESYNC_SKILLS_RELATIVE_DIR_PATH as En, applyFileMode as Et, caseFoldIdentity as F, formatError as Fn, getFileSize as Ft, RulesyncRuleFrontmatterSchema as G, readFileContentOrNull as Gt, RulesyncSkill as H, stripHiddenCharacters as Hn, listSubdirectoryNames as Ht, groupSpellingsByCaseFoldedIdentity as I, truncateText as In, getHomeDirectory as It, RulesyncIgnore as J, removeFile as Jt, RulesyncPermissions as K, removeDirectory as Kt, AUGMENTCODE_DIR as L, hasDeceptiveHiddenCharacters as Ln, isFileNotFoundError as Lt, CLAUDECODE_SKILLS_DIR_PATH as M, ALL_FEATURES as Mn, directoryExists as Mt, FACTORYDROID_DIR as N, ALL_FEATURES_WITH_WILDCARD as Nn, ensureDir as Nt, CLAUDECODE_DIR as O, RULESYNC_SUBAGENTS_RELATIVE_DIR_PATH as On, assertTreeContainsNoSymlinks as Ot, FACTORYDROID_SETTINGS_LOCAL_FILE_NAME as P, DEPRECATED_FEATURE_REPLACEMENTS as Pn, fileExists as Pt, parseJsonc as Q, runWithDirectoryRollback as Qt, AUGMENTCODE_SETTINGS_LOCAL_FILE_NAME as R, hasEnclosingMarkOutsideKeycap as Rn, isFileSystemError as Rt, QWENCODE_LOCAL_RULE_FILE_NAME as S, RULESYNC_PERMISSIONS_RELATIVE_FILE_PATH as Sn, resetRunWarningState as St, ChecksProcessor as T, RULESYNC_RULES_RELATIVE_DIR_PATH as Tn, ErrorCodes as Tt, RulesyncSkillFrontmatterSchema as U, pathEscapesRoot as Ut, RulesyncSubagentFrontmatterSchema as V, stripControlCharactersKeepingLineFeeds as Vn, listFilePathsRecursively as Vt, RulesyncRule as W, readFileContent as Wt, getRulesyncSourceCandidates as X, removeTempDirectory as Xt, RulesyncHooks as Y, removeFileStrict as Yt, resolveRulesyncSourceWritePath as Z, resolvePath as Zt, IgnoreProcessor as _, RULESYNC_IGNORE_RELATIVE_FILE_PATH as _n, JsonLogger as _t, getProcessorRegistryEntry as a, ToolTargetSchema as an, SHARED_USER_MANAGED_CONFIG_PATHS as at, CommandsProcessor as b, RULESYNC_MCP_SCHEMA_URL as bn, warnOnConflictingFlags as bt, RulesProcessor as c, MAX_FILE_SIZE as cn, mergeInputRootConfigs as ct, CODEBUDDY_DIR as d, RULESYNC_COMMANDS_RELATIVE_DIR_PATH as dn, ConfigFileSchema as dt, writeFileBuffer as en, RulesyncCommandFrontmatterSchema as et, CODEBUDDY_LOCAL_RULE_FILE_NAME as f, RULESYNC_CONFIG_RELATIVE_FILE_PATH as fn, GITIGNORE_DESTINATION_KEY as ft, McpProcessor as g, RULESYNC_HOOKS_RELATIVE_FILE_PATH as gn, ConsoleLogger as gt, shortenToWidth as h, RULESYNC_CURATED_SKILLS_RELATIVE_DIR_PATH as hn, findControlCharacter as ht, inspectInputRoots as i, PACKAGING_TOOL_TARGETS as in, loadYaml as it, CLAUDECODE_SETTINGS_LOCAL_FILE_NAME as j, parseCommaSeparatedList as jn, createTempDirectory as jt, CLAUDECODE_LOCAL_RULE_FILE_NAME as k, RULESYNC_USER_CONFIG_DIR_NAME as kn, assertWritablePathInsideRoot as kt, SubagentsProcessor as l, RULESYNC_AIIGNORE_RELATIVE_FILE_PATH as ln, resolveEffectiveInputRoots as lt, displayWidthOf as m, RULESYNC_CURATED_RULES_RELATIVE_DIR_PATH as mn, assertTargetsFeaturesExclusive as mt, formatSourceLoadFailure as n, ALL_TOOL_TARGETS as nn, RulesyncCheckFrontmatterSchema as nt, convertFromTool as o, CURATED_RULES_FEATURE_SUBDIR as on, SKILL_FILE_NAME as ot, ELLIPSIS_WIDTH as p, RULESYNC_CONFIG_SCHEMA_URL as pn, SourceEntrySchema as pt, RulesyncMcp as q, removeDirectoryStrict as qt, generate as r, ALL_TOOL_TARGETS_WITH_WILDCARD as rn, stringifyFrontmatter as rt, isPackagingToolTarget as s, FEATURE_SOURCE_TREE_ENTRIES as sn, ConfigResolver as st, importFromTool as t, writeFileContent as tn, RulesyncCheck as tt, SkillsProcessor as u, RULESYNC_CHECKS_RELATIVE_DIR_PATH as un, CONFLICTING_TARGET_PAIRS as ut, HooksProcessor as v, RULESYNC_LOCAL_CONFIG_RELATIVE_FILE_PATH as vn, WarningCollectingLogger as vt, COMMANDCODE_SETTINGS_LOCAL_FILE_NAME as w, RULESYNC_RELATIVE_DIR_PATH as wn, CLIError as wt, QWENCODE_DIR as x, RULESYNC_NPM_SOURCES_LOCK_RELATIVE_FILE_PATH as xn, withFallbackLoggerTarget as xt, CRUSH_LOCAL_RULE_FILE_NAME as y, RULESYNC_MCP_RELATIVE_FILE_PATH as yn, fallbackLogger as yt, getLocalSkillDirNames as z, quoteForLog as zn, isSymlink as zt };
 
-//# sourceMappingURL=import-BJsTd50i.js.map
+//# sourceMappingURL=import-DxRza3o_.js.map