rulesync 16.6.0 → 16.7.0

package/dist/{import-D87qlRUj.cjs → import-XhKI9ZRY.cjs}

@@ -639,6 +639,13 @@ async function readFileBuffer(filepath) {
 	return (0, node_fs_promises.readFile)(filepath);
 }
 /**
+* Read file as a buffer if it exists, otherwise return null.
+*/
+async function readFileBufferOrNull(filepath) {
+	if (await fileExists(filepath)) return readFileBuffer(filepath);
+	return null;
+}
+/**
 * Normalizes text to LF line endings and adds exactly one trailing newline.
 * Removes any existing trailing whitespace and appends a single newline.
 */
@@ -650,6 +657,10 @@ async function writeFileContent(filepath, content) {
 	await ensureDir((0, node_path.dirname)(filepath));
 	await (0, node_fs_promises.writeFile)(filepath, content, "utf-8");
 }
+async function writeFileBuffer(filepath, buffer) {
+	await ensureDir((0, node_path.dirname)(filepath));
+	await (0, node_fs_promises.writeFile)(filepath, buffer);
+}
 async function fileExists(filepath) {
 	try {
 		await (0, node_fs_promises.stat)(filepath);
@@ -2182,6 +2193,7 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.optional(safeString),
 	description: zod_mini.z.optional(safeString),
 	failClosed: zod_mini.z.optional(zod_mini.z.boolean()),
+	commandRegex: zod_mini.z.optional(safeString),
 	sequential: zod_mini.z.optional(zod_mini.z.boolean()),
 	async: zod_mini.z.optional(zod_mini.z.boolean()),
 	env: zod_mini.z.optional(zod_mini.z.record(zod_mini.z.string(), safeString)),
@@ -2198,6 +2210,7 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	if: zod_mini.z.optional(safeString),
 	commandWindows: zod_mini.z.optional(safeString),
+	additionalContextLimit: zod_mini.z.optional(zod_mini.z.int().check((0, zod_mini.nonnegative)())),
 	asyncRewake: zod_mini.z.optional(zod_mini.z.boolean()),
 	continueOnBlock: zod_mini.z.optional(zod_mini.z.boolean())
 });
@@ -4245,7 +4258,8 @@ const ReasonixPermissionsOverrideSchema = zod_mini.z.looseObject({
 */
 const FactorydroidPermissionsOverrideSchema = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
-	commandBlocklist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
+	commandBlocklist: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string())),
+	disabledSkills: zod_mini.z.optional(zod_mini.z.array(zod_mini.z.string()))
 });
 /**
 * Tool-scoped override block for Warp. Warp's `[agents.profiles]` table exposes
@@ -4691,13 +4705,22 @@ const CodexBasePermissionProfileSchema = zod_mini.z.enum(CODEX_BASE_PERMISSION_P
 *   `base_permission_profile` it is consumed by the profile builder, not
 *   written as a top-level config key.
 *
-* 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
-* MCP feature (`codexcli-mcp.ts` already writes the `mcp_servers` tables in the
-* same `config.toml`), and `permissions` / `default_permissions` are owned by
-* the canonical model. Any such key placed in the override is skipped with a
-* warning. Kept `looseObject` (verbatim passthrough) so future top-level Codex
-* config keys can be authored without Rulesync modeling each one.
+* The keys written to `config.toml` are an **allowlist**, not verbatim
+* passthrough: only `CODEXCLI_OVERRIDE_KEYS`
+* (`src/constants/codexcli-paths.ts` — `approval_policy`, `sandbox_mode`,
+* `sandbox_workspace_write`, `apps`, `approvals_reviewer`) are emitted, and
+* `computeCodexcliOverridePatch` skips anything else with a warning.
+* `base_permission_profile` and `git_write_rules` are consumed by the profile
+* builder rather than written, as described above, and `permission` is the
+* tool-scoped canonical block, which `RulesyncPermissions.forTarget` strips out
+* of the override before it ever reaches the patch. The allowlist is what keeps
+* the override from clobbering a feature-owned key: `mcp_servers.*` per-MCP
+* gating is owned by the MCP feature (`codexcli-mcp.ts` already writes the
+* `mcp_servers` tables in the same `config.toml`), and `permissions` /
+* `default_permissions` are owned by the canonical model. The schema itself is
+* `looseObject` so an unmodeled key parses (and is then reported rather than
+* rejected outright); supporting a new top-level Codex config key means adding
+* it to `CODEXCLI_OVERRIDE_KEYS`.
 *
 * @see https://developers.openai.com/codex/config-reference
 * @see https://developers.openai.com/codex/permissions
@@ -5172,7 +5195,11 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	})),
 	copilot: zod_mini.z.optional(zod_mini.z.looseObject({
 		license: zod_mini.z.optional(zod_mini.z.string()),
-		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+		"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
+		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
+		context: zod_mini.z.optional(zod_mini.z.string())
 	})),
 	copilotcli: zod_mini.z.optional(zod_mini.z.looseObject({
 		license: zod_mini.z.optional(zod_mini.z.string()),
@@ -5230,7 +5257,9 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 	})),
 	factorydroid: zod_mini.z.optional(zod_mini.z.looseObject({
 		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
-		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean())
+		"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+		enabled: zod_mini.z.optional(zod_mini.z.boolean()),
+		"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
 	})),
 	grokcli: zod_mini.z.optional(zod_mini.z.looseObject({
 		"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
@@ -5443,8 +5472,8 @@ async function getLocalSkillDirNames(outputRoot) {
 * Resolve the effective `disable-model-invocation` value for a tool skill.
 *
 * The rulesync skill frontmatter exposes a root-level `disable-model-invocation`
-* default that applies to every tool supporting the flag (claudecode, cursor,
-* zed, pi, qwencode, grokcli, factorydroid). Each tool's own section may override that
+* default that applies to every tool supporting the flag (claudecode, copilot,
+* copilotcli, cursor, zed, pi, qwencode, grokcli, factorydroid). 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.
 *
@@ -5457,8 +5486,8 @@ function resolveDisableModelInvocation({ rootFrontmatter, section }) {
 * Resolve the effective `user-invocable` value for a tool skill.
 *
 * The rulesync skill frontmatter exposes a root-level `user-invocable` default
-* that applies to every tool supporting the flag (claudecode, qwencode, vibe,
-* grokcli, factorydroid). Each tool's own section may override that default with a
+* that applies to every tool supporting the flag (claudecode, copilot,
+* copilotcli, qwencode, vibe, grokcli, factorydroid). 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.
 *
@@ -5671,6 +5700,31 @@ function fileContentsEquivalent({ filePath, expected, existing }) {
 	if (structured !== void 0) return structured;
 	return addTrailingNewline(expected) === addTrailingNewline(existing);
 }
+/**
+* Whether an on-disk companion file is equivalent to the generated one.
+*
+* Companion files (everything beside a skill's `SKILL.md`) are written byte for
+* byte, so byte equality is the whole test for a user asset carried through
+* from the source directory: a CRLF fixture or a deliberately newline-less file
+* must compare equal to itself and unequal to a normalized copy, and a copy
+* that has drifted must be repaired rather than tolerated.
+*
+* A `composed` file is different — Rulesync builds it from frontmatter (Codex
+* CLI's `agents/openai.yaml`), so differing bytes fall back to the structured
+* comparison and a formatter re-indenting it is not reported as a change on
+* every generate. Only the structured verdict counts: there is deliberately no
+* text fallback, since trailing-whitespace-insensitive text equality is exactly
+* the normalization companion files no longer get.
+*/
+function companionFileContentsEquivalent({ filePath, expected, existing, composed = false }) {
+	if (existing === null) return false;
+	if (existing.equals(expected)) return true;
+	if (!composed) return false;
+	const expectedText = expected.toString("utf-8");
+	const existingText = existing.toString("utf-8");
+	if (!Buffer.from(expectedText, "utf-8").equals(expected) || !Buffer.from(existingText, "utf-8").equals(existing)) return false;
+	return tryFileContentsEquivalent(filePath, expectedText, existingText) ?? false;
+}
 //#endregion
 //#region src/types/feature-processor.ts
 var FeatureProcessor = class {
@@ -7071,6 +7125,14 @@ const SHARED_CONFIG_OWNERSHIP = {
 			ownedKeys: ["mcp", "tools"]
 		} }
 	},
+	".config/goose/config.yaml": {
+		format: "yaml",
+		invalidRootPolicy: "error",
+		features: { mcp: {
+			kind: "replace-owned-keys",
+			ownedKeys: ["extensions"]
+		} }
+	},
 	[CODEXCLI_CONFIG_SHARED_FILE_KEY]: {
 		format: "toml",
 		features: {
@@ -9309,9 +9371,10 @@ const FACTORYDROID_HOOKS_FILE_NAME = "hooks.json";
 //#region src/features/commands/factorydroid-command.ts
 const FactorydroidCommandFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
-	"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
-	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+	"argument-hint": zod_mini.z.optional(zod_mini.z.string())
 });
+/** Not a Droid command surface; see the schema comment above. */
+const FACTORYDROID_UNSUPPORTED_COMMAND_FIELDS = ["allowed-tools"];
 var FactorydroidCommand = class FactorydroidCommand extends ToolCommand {
 	frontmatter;
 	body;
@@ -9338,6 +9401,7 @@ var FactorydroidCommand = class FactorydroidCommand extends ToolCommand {
 	}
 	toRulesyncCommand() {
 		const { description, ...restFields } = this.frontmatter;
+		for (const field of FACTORYDROID_UNSUPPORTED_COMMAND_FIELDS) delete restFields[field];
 		const rulesyncFrontmatter = {
 			targets: ["*"],
 			description,
@@ -9361,6 +9425,7 @@ var FactorydroidCommand = class FactorydroidCommand extends ToolCommand {
 			description: rulesyncFrontmatter.description,
 			...factorydroidFields
 		};
+		for (const field of FACTORYDROID_UNSUPPORTED_COMMAND_FIELDS) delete factorydroidFrontmatter[field];
 		const body = rulesyncCommand.getBody();
 		const paths = this.getSettablePaths({ global });
 		return new FactorydroidCommand({
@@ -13072,16 +13137,28 @@ function buildEffectiveHooks$1({ config, toolOverrideHooks, supportedEvents }) {
 	};
 }
 /**
-* Group a list of hook definitions by their `matcher` (empty string when absent),
-* preserving insertion order of both keys and grouped definitions.
+* Group a list of hook definitions by their `matcher` (empty string when
+* absent), preserving insertion order of both keys and grouped definitions.
+* Definitions that disagree on a `subdividesGroup` passthrough field are split
+* into separate groups, so a restricting field is never inherited by a hook
+* that did not ask for it.
 */
-function groupDefinitionsByMatcher(definitions) {
+function groupDefinitionsByMatcher({ definitions, converterConfig }) {
+	const subdividingFields = (converterConfig.groupPassthroughFields ?? []).filter(({ subdividesGroup }) => subdividesGroup);
 	const byMatcher = /* @__PURE__ */ new Map();
 	for (const def of definitions) {
-		const key = def.matcher ?? "";
-		const list = byMatcher.get(key);
-		if (list) list.push(def);
-		else byMatcher.set(key, [def]);
+		const rawMatcher = def.matcher ?? "";
+		const matcher = converterConfig.wildcardMatcherMeansAll && rawMatcher === "*" ? "" : rawMatcher;
+		const key = [matcher, ...subdividingFields.map(({ canonical, valueType }) => {
+			const value = def[canonical];
+			return isGroupPassthroughValue(value, valueType) ? stableJson(value) : "";
+		})].join("\0");
+		const group = byMatcher.get(key);
+		if (group) group.defs.push(def);
+		else byMatcher.set(key, {
+			matcher,
+			defs: [def]
+		});
 	}
 	return byMatcher;
 }
@@ -13126,6 +13203,24 @@ function importBooleanPassthroughFields({ h, converterConfig }) {
 	return Object.fromEntries((converterConfig.booleanPassthroughFields ?? []).filter(({ tool }) => typeof h[tool] === "boolean").map(({ canonical, tool }) => [canonical, h[tool]]));
 }
 /**
+* Emit the configured number passthrough fields on the tool side, mapping each
+* canonical field name to its (possibly renamed) tool field name. Only finite
+* numbers are carried through.
+*/
+function emitNumberPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.numberPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return Number.isFinite(def[canonical]);
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
+}
+/**
+* Import the configured number passthrough fields back into canonical fields,
+* reversing {@link emitNumberPassthroughFields}. Only finite numbers are read.
+*/
+function importNumberPassthroughFields({ h, converterConfig }) {
+	return Object.fromEntries((converterConfig.numberPassthroughFields ?? []).filter(({ tool }) => Number.isFinite(h[tool])).map(({ canonical, tool }) => [canonical, h[tool]]));
+}
+/**
 * Emit the configured string passthrough fields on the tool side, mapping each
 * canonical field name to its (possibly renamed) tool field name. Only non-empty
 * string values are carried through.
@@ -13163,17 +13258,45 @@ function importArrayPassthroughFields({ h, converterConfig, logger }) {
 	return Object.fromEntries(fields.filter(({ tool }) => isSafeStringArray(h[tool])).map(({ canonical, tool }) => [canonical, h[tool]]));
 }
 /**
+* Emit the configured string-map passthrough fields on the tool side. Only maps
+* whose values are all control-character-free strings are carried through.
+*/
+function emitRecordPassthroughFields({ def, hookType, converterConfig }) {
+	return Object.fromEntries((converterConfig.recordPassthroughFields ?? []).filter(({ canonical, commandOnly }) => {
+		if (commandOnly === true && hookType !== "command") return false;
+		return isSafeStringRecord(def[canonical]);
+	}).map(({ canonical, tool }) => [tool, def[canonical]]));
+}
+/**
+* Import the configured string-map passthrough fields, reversing
+* {@link emitRecordPassthroughFields}.
+*/
+function importRecordPassthroughFields({ h, hookType, converterConfig, logger }) {
+	const fields = (converterConfig.recordPassthroughFields ?? []).filter(({ commandOnly }) => commandOnly !== true || hookType === "command");
+	for (const { tool } of fields) if (h[tool] !== void 0 && !isSafeStringRecord(h[tool])) logger?.warn(`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.`);
+	return Object.fromEntries(fields.filter(({ tool }) => isSafeStringRecord(h[tool])).map(({ canonical, tool }) => [canonical, h[tool]]));
+}
+/**
+* Check a value against the shape its field documents. A string field also
+* rejects control characters, matching the canonical `safeString` so an
+* imported value cannot fail validation on the next generate.
+*/
+function isGroupPassthroughValue(value, valueType = "object") {
+	if (valueType === "string") return typeof value === "string" && !CONTROL_CHARS.some((char) => value.includes(char));
+	return isPlainObject$1(value);
+}
+/**
 * Emit the configured group-level passthrough fields, taken from the first
 * definition of the group that carries one.
 */
 function emitGroupPassthroughFields({ defs, eventName, converterConfig, logger }) {
 	const emitted = {};
-	for (const { canonical, tool } of converterConfig.groupPassthroughFields ?? []) {
+	for (const { canonical, tool, valueType } of converterConfig.groupPassthroughFields ?? []) {
 		const carried = defs.map((def) => def[canonical]);
-		const first = carried.find((value) => isPlainObject$1(value));
+		const first = carried.find((value) => isGroupPassthroughValue(value, valueType));
 		if (first === void 0) continue;
 		const firstStable = stableJson(first);
-		const agrees = (value) => isPlainObject$1(value) && stableJson(value) === firstStable;
+		const agrees = (value) => isGroupPassthroughValue(value, valueType) && stableJson(value) === firstStable;
 		if (!carried.every(agrees)) logger?.warn(`"${tool}" belongs to the whole matcher group on "${eventName}" hooks, so every hook in this group gets ${JSON.stringify(first)} — including any that asked for something else, or for nothing.`);
 		emitted[tool] = first;
 	}
@@ -13185,7 +13308,7 @@ function emitGroupPassthroughFields({ defs, eventName, converterConfig, logger }
 */
 function importGroupPassthroughFields({ rawEntry, converterConfig }) {
 	const entry = rawEntry;
-	return Object.fromEntries((converterConfig.groupPassthroughFields ?? []).filter(({ tool }) => isPlainObject$1(entry[tool])).map(({ canonical, tool }) => [canonical, entry[tool]]));
+	return Object.fromEntries((converterConfig.groupPassthroughFields ?? []).filter(({ tool, valueType }) => isGroupPassthroughValue(entry[tool], valueType)).map(({ canonical, tool }) => [canonical, entry[tool]]));
 }
 /**
 * Emit the payload fields specific to a hook type — `url`/`headers`/
@@ -13231,6 +13354,11 @@ function buildToolHooks({ defs, converterConfig }) {
 				hookType,
 				converterConfig
 			}),
+			...emitNumberPassthroughFields({
+				def,
+				hookType,
+				converterConfig
+			}),
 			...emitStringPassthroughFields({
 				def,
 				hookType,
@@ -13241,6 +13369,11 @@ function buildToolHooks({ defs, converterConfig }) {
 				hookType,
 				converterConfig
 			}),
+			...emitRecordPassthroughFields({
+				def,
+				hookType,
+				converterConfig
+			}),
 			type: hookType,
 			...command !== void 0 && command !== null && { command },
 			...def.timeout !== void 0 && def.timeout !== null && { timeout: def.timeout },
@@ -13271,10 +13404,13 @@ function canonicalToToolHooks({ config, toolOverrideHooks, converterConfig, logg
 	const result = {};
 	for (const [eventName, definitions] of Object.entries(effectiveHooks)) {
 		const toolEventName = converterConfig.canonicalToToolEventNames[eventName] ?? eventName;
-		const byMatcher = groupDefinitionsByMatcher(definitions);
+		const byMatcher = groupDefinitionsByMatcher({
+			definitions,
+			converterConfig
+		});
 		const entries = [];
 		const isNoMatcherEvent = converterConfig.noMatcherEvents?.has(eventName) ?? false;
-		for (const [matcherKey, defs] of byMatcher) {
+		for (const { matcher: matcherKey, defs } of byMatcher.values()) {
 			if (isNoMatcherEvent && matcherKey) logger?.warn(`matcher "${matcherKey}" on "${eventName}" hook will be ignored — this event does not support matchers`);
 			const hooks = buildToolHooks({
 				defs,
@@ -13354,9 +13490,27 @@ function isStringArray(value) {
 }
 /** Compare object values without letting key order decide the answer. */
 function stableJson(value) {
+	if (typeof value === "string") return JSON.stringify(value);
 	return JSON.stringify(Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a.localeCompare(b))));
 }
 /**
+* A string map safe to hand a tool as a hook's environment block. On top of
+* {@link isStringRecord} it rejects a non-plain object (a class instance is not
+* data) and applies the control-character rule to the values, as
+* {@link isSafeStringArray} does for `args`.
+*
+* The keys are checked more strictly than the values. A tool builds each entry
+* back into a `KEY=VALUE` string for the spawned process, so a key holding `=`
+* (or a control character, or nothing at all) names a different variable than
+* it appears to — `PATH=/tmp/evil` written as a key would set `PATH`. An
+* authored `.rulesync/hooks.*` can arrive via `rulesync fetch`, so that is not
+* a shape to pass along.
+*/
+function isSafeStringRecord(value) {
+	if (!isPlainObject$1(value) || !isStringRecord(value)) return false;
+	return Object.entries(value).every(([key, entry]) => key !== "" && !key.includes("=") && !CONTROL_CHARS.some((char) => key.includes(char) || entry.includes(char)));
+}
+/**
 * Control characters cannot ride from an existing tool config into a canonical
 * field the schema guards with `safeString`, or the next generate fails
 * validation on a file this import itself wrote — and the hooks feature is
@@ -13409,6 +13563,10 @@ function toolHookToCanonical({ h, rawEntry, converterConfig, logger }) {
 			h,
 			converterConfig
 		}),
+		...importNumberPassthroughFields({
+			h,
+			converterConfig
+		}),
 		...importStringPassthroughFields({
 			h,
 			converterConfig
@@ -13418,6 +13576,12 @@ function toolHookToCanonical({ h, rawEntry, converterConfig, logger }) {
 			converterConfig,
 			logger
 		}),
+		...importRecordPassthroughFields({
+			h,
+			hookType,
+			converterConfig,
+			logger
+		}),
 		...importGroupPassthroughFields({
 			rawEntry,
 			converterConfig
@@ -13935,6 +14099,14 @@ var ClaudecodeHooks = class extends ToolHooks {
 	isDeletable() {
 		return false;
 	}
+	/**
+	* The converter config used for both directions. Exposed as a static hook so
+	* plugin-scoped subclasses can swap tool-specific details (e.g. the project
+	* directory variable) without duplicating the rest of the config.
+	*/
+	static getConverterConfig() {
+		return CLAUDE_CONVERTER_CONFIG;
+	}
 	static getSettablePaths(_options = {}) {
 		return {
 			relativeDirPath: CLAUDECODE_DIR,
@@ -13960,7 +14132,7 @@ var ClaudecodeHooks = class extends ToolHooks {
 		const claudeHooks = canonicalToToolHooks({
 			config,
 			toolOverrideHooks: config.claudecode?.hooks,
-			converterConfig: CLAUDE_CONVERTER_CONFIG,
+			converterConfig: this.getConverterConfig(),
 			logger
 		});
 		const fileContent = applySharedConfigPatch({
@@ -13987,7 +14159,7 @@ var ClaudecodeHooks = class extends ToolHooks {
 		}
 		const hooks = toolHooksToCanonical({
 			hooks: settings.hooks,
-			converterConfig: CLAUDE_CONVERTER_CONFIG
+			converterConfig: this.constructor.getConverterConfig()
 		});
 		return this.toRulesyncHooksDefault({ fileContent: JSON.stringify(buildImportedHooksConfig({
 			hooks,
@@ -14016,6 +14188,21 @@ var ClaudecodePluginHooks = class extends ClaudecodeHooks {
 	isDeletable() {
 		return true;
 	}
+	/**
+	* Plugin hook scripts ship inside the plugin, so their commands must resolve
+	* against the plugin install directory rather than the consumer's project
+	* root. Upstream documents `"${CLAUDE_PLUGIN_ROOT}"/scripts/format-code.sh`;
+	* `$CLAUDE_PROJECT_DIR` would expand to a path in the consumer's own repo,
+	* where the bundled script does not exist.
+	*
+	* @see https://code.claude.com/docs/en/plugins-reference
+	*/
+	static getConverterConfig() {
+		return {
+			...super.getConverterConfig(),
+			projectDirVar: "$CLAUDE_PLUGIN_ROOT"
+		};
+	}
 	static getSettablePaths() {
 		return {
 			relativeDirPath: CLAUDECODE_PLUGIN_HOOKS_DIR,
@@ -14038,6 +14225,10 @@ const CODEXCLI_CONVERTER_CONFIG = {
 	}, {
 		canonical: "statusMessage",
 		tool: "statusMessage"
+	}],
+	numberPassthroughFields: [{
+		canonical: "additionalContextLimit",
+		tool: "additionalContextLimit"
 	}]
 };
 /**
@@ -15081,7 +15272,13 @@ const FACTORYDROID_CONVERTER_CONFIG = {
 	toolToCanonicalEventNames: FACTORYDROID_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "$FACTORY_PROJECT_DIR",
 	prefixDotRelativeCommandsOnly: true,
-	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	groupPassthroughFields: [{
+		canonical: "commandRegex",
+		tool: "commandRegex",
+		valueType: "string",
+		subdividesGroup: true
+	}]
 };
 var FactorydroidHooks = class FactorydroidHooks extends ToolHooks {
 	constructor(params) {
@@ -15177,7 +15374,8 @@ const GOOSE_CONVERTER_CONFIG = {
 	canonicalToToolEventNames: CANONICAL_TO_GOOSE_EVENT_NAMES,
 	toolToCanonicalEventNames: GOOSE_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "",
-	supportedHookTypes: /* @__PURE__ */ new Set(["command"])
+	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	wildcardMatcherMeansAll: true
 };
 /**
 * Represents a Goose lifecycle hooks file.
@@ -15272,6 +15470,11 @@ const GROKCLI_CONVERTER_CONFIG = {
 	toolToCanonicalEventNames: GROKCLI_TO_CANONICAL_EVENT_NAMES,
 	projectDirVar: "",
 	supportedHookTypes: /* @__PURE__ */ new Set(["command", "http"]),
+	recordPassthroughFields: [{
+		canonical: "env",
+		tool: "env",
+		commandOnly: true
+	}],
 	noMatcherEvents: /* @__PURE__ */ new Set([
 		"sessionStart",
 		"sessionEnd",
@@ -21222,6 +21425,27 @@ function resolveGooseType(config, url) {
 	return canonicalTransport(config) === "builtin" ? "builtin" : "stdio";
 }
 /**
+* The Goose extension types that carry an MCP server. Goose also documents
+* `builtin`, `platform`, `frontend` and `inline_python` extensions, which have
+* no canonical MCP counterpart: they name capabilities Goose provides itself
+* rather than a server rulesync could describe.
+*/
+const GOOSE_MCP_EXTENSION_TYPES = /* @__PURE__ */ new Set([
+	"stdio",
+	"streamable_http",
+	"sse"
+]);
+/**
+* Resolves the Goose extension type of an existing `extensions:` entry the way
+* Goose itself reads it: the declared `type`, or the shape of the entry when
+* the key is absent.
+*/
+function existingExtensionType(ext) {
+	if (typeof ext.type === "string") return ext.type;
+	if (typeof ext.cmd === "string") return "stdio";
+	if (typeof ext.uri === "string") return "streamable_http";
+}
+/**
 * Resolves the canonical timeout for a server (`timeout` or `networkTimeout`).
 */
 function resolveGooseTimeout(config) {
@@ -21247,15 +21471,20 @@ function applyGooseStdioFields(ext, config) {
 /**
 * Converts a single rulesync canonical MCP server into a Goose `extensions:` entry.
 */
-function convertServerToGooseExtension(name, config) {
+function convertServerToGooseExtension(name, config, logger) {
 	const url = resolveGooseUrl(config);
 	const gooseType = resolveGooseType(config, url);
 	const ext = {
 		name,
 		type: gooseType
 	};
-	if (gooseType === "stdio") applyGooseStdioFields(ext, config);
-	else if (gooseType === "sse" || gooseType === "streamable_http") {
+	if (gooseType === "stdio") {
+		applyGooseStdioFields(ext, config);
+		if (typeof ext.cmd !== "string" || ext.cmd === "") {
+			warnWithFallback(logger, `Goose extension "${name}" has no command to run; skipping it rather than writing a stdio extension Goose cannot start to ~/.config/goose/config.yaml.`);
+			return;
+		}
+	} else if (gooseType === "sse" || gooseType === "streamable_http") {
 		if (url !== void 0) ext.uri = url;
 		if (isPlainObject$1(config.headers)) ext.headers = omitPrototypePollutionKeys(config.headers);
 	}
@@ -21270,13 +21499,41 @@ function convertServerToGooseExtension(name, config) {
 * Goose uses a non-standard schema: `name`, `type` (`stdio` | `streamable_http`
 * | `sse` | `builtin`), `cmd`/`args`/`envs` for stdio, `uri`/`headers` for
 * remote, plus `enabled` and `timeout`.
-*/
-function convertToGooseFormat(mcpServers) {
-	const extensions = {};
+*
+* `extensions:` is co-owned: alongside the MCP servers rulesync manages it also
+* holds Goose's own `builtin`/`platform`/`frontend`/`inline_python` extensions
+* (`developer`, `memory`, ...), which have no canonical MCP representation.
+* Those entries are carried over from `existingExtensions` untouched — removing
+* `developer` alone costs the agent its shell and text-editor tools. Only an
+* entry rulesync can positively identify as an MCP server is rulesync's to
+* replace, so a server deleted from `.rulesync/.mcp.json` is retracted (with a
+* warning naming it) while an entry of an unrecognized shape or a future
+* extension type is left alone rather than assumed to be ours.
+*/
+function convertToGooseFormat({ mcpServers, existingExtensions, logger }) {
+	const generated = {};
 	for (const [name, config] of Object.entries(mcpServers)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(config)) continue;
-		extensions[name] = convertServerToGooseExtension(name, config);
+		const ext = convertServerToGooseExtension(name, config, logger);
+		if (ext !== void 0) generated[name] = ext;
 	}
+	const extensions = {};
+	const retracted = [];
+	for (const [name, ext] of Object.entries(existingExtensions)) {
+		if (PROTOTYPE_POLLUTION_KEYS.has(name)) continue;
+		const type = isRecord(ext) ? existingExtensionType(ext) : void 0;
+		if (type !== void 0 && GOOSE_MCP_EXTENSION_TYPES.has(type)) {
+			if (!Object.hasOwn(generated, name)) retracted.push(name);
+			continue;
+		}
+		if (!Object.hasOwn(generated, name)) {
+			extensions[name] = ext;
+			continue;
+		}
+		if (generated[name]?.type !== type) warnWithFallback(logger, `Goose extension "${name}" already exists in config.yaml as a non-MCP extension; the MCP server of the same name replaces it.`);
+	}
+	if (retracted.length > 0) warnWithFallback(logger, `Removing MCP extension(s) ${retracted.map((name) => `"${name}"`).join(", ")} from ~/.config/goose/config.yaml: they are not in the generated rulesync MCP config. Import them first if they were added with \`goose configure\`.`);
+	Object.assign(extensions, generated);
 	return extensions;
 }
 /**
@@ -21287,16 +21544,27 @@ function convertToGooseFormat(mcpServers) {
 * so both `url` and the Claude-specific `httpUrl` alias come back as `url`; and
 * the `streamable_http` type maps back to canonical `http`. These are the
 * canonical/preferred forms, so re-generating produces an equivalent config.
+*
+* Non-MCP extension types (`builtin`, `platform`, `frontend`, `inline_python`)
+* are skipped: they describe capabilities Goose provides itself, and importing
+* one would strip the type that makes it work — a `builtin` entry came back as
+* a `stdio` extension with no `cmd` that Goose cannot start. They stay in `config.yaml`,
+* which generation preserves.
 */
 function convertFromGooseFormat(extensions) {
 	const result = {};
+	const skipped = [];
 	for (const [name, ext] of Object.entries(extensions)) {
 		if (PROTOTYPE_POLLUTION_KEYS.has(name) || !isRecord(ext)) continue;
+		const type = existingExtensionType(ext);
+		if (type === void 0 || !GOOSE_MCP_EXTENSION_TYPES.has(type)) {
+			skipped.push(name);
+			continue;
+		}
 		const server = {};
-		const type = typeof ext.type === "string" ? ext.type : void 0;
 		if (type === "sse") server.type = "sse";
 		else if (type === "streamable_http") server.type = "http";
-		else if (type === "stdio") server.type = "stdio";
+		else server.type = "stdio";
 		if (typeof ext.cmd === "string") server.command = ext.cmd;
 		if (isStringArray$1(ext.args)) server.args = ext.args;
 		if (isPlainObject$1(ext.envs)) server.env = omitPrototypePollutionKeys(ext.envs);
@@ -21306,6 +21574,7 @@ function convertFromGooseFormat(extensions) {
 		if (typeof ext.timeout === "number") server.timeout = ext.timeout;
 		result[name] = server;
 	}
+	if (skipped.length > 0) warnWithFallback(void 0, `Skipping ${skipped.length} non-MCP Goose extension(s) (${skipped.map((name) => `"${name}"`).join(", ")}): they describe capabilities Goose provides itself and have no rulesync representation.`);
 	return result;
 }
 /**
@@ -21427,15 +21696,25 @@ var GooseMcp = class GooseMcp extends ToolMcp {
 				global
 			});
 		}
-		const merged = {
-			...parseGooseConfig(await readFileContentOrNull((0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath)) ?? "", paths.relativeDirPath, paths.relativeFilePath),
-			extensions: convertToGooseFormat(rulesyncMcp.getMcpServers())
-		};
+		const filePath = (0, node_path.join)(outputRoot, paths.relativeDirPath, paths.relativeFilePath);
+		const existingContent = await readFileContentOrNull(filePath) ?? "";
+		const config = parseGooseConfig(existingContent, paths.relativeDirPath, paths.relativeFilePath);
+		const existingExtensions = isRecord(config.extensions) ? config.extensions : {};
 		return new GooseMcp({
 			outputRoot,
 			relativeDirPath: paths.relativeDirPath,
 			relativeFilePath: paths.relativeFilePath,
-			fileContent: (0, js_yaml.dump)(merged),
+			fileContent: applySharedConfigPatch({
+				fileKey: sharedConfigFileKey(paths),
+				feature: "mcp",
+				existingContent,
+				patch: { extensions: convertToGooseFormat({
+					mcpServers: rulesyncMcp.getMcpServers(),
+					existingExtensions,
+					logger
+				}) },
+				filePath
+			}),
 			validate,
 			global
 		});
@@ -28144,7 +28423,8 @@ const FACTORYDROID_OVERRIDE_KEYS = [
 	"interactionMode",
 	"extraKnownMarketplaces",
 	"enabledPlugins",
-	"hooksDisabled"
+	"hooksDisabled",
+	"disabledSkills"
 ];
 /**
 * Permissions adapter for Factory Droid.
@@ -32295,6 +32575,30 @@ const CANONICAL_TO_ZED_TOOL_NAMES = {
 	webfetch: "fetch",
 	websearch: "search_web"
 };
+/**
+* Canonical categories whose Zed tool is not permission-gated. Zed's gated list
+* is `terminal`, `edit_file`, `write_file`, `delete_path`, `move_path`,
+* `copy_path`, `create_directory`, `fetch`, `search_web` and `skill`; the
+* read-only tools (`read_file`, `grep`, `find_path`, `list_directory`) sit in
+* Zed's own `EXCLUDED_TOOLS` and never call `decide_permission_from_settings`,
+* so a `tools.<name>` entry for one is config Zed never consults. Zed's real
+* read-denial surface is `private_files`, which the ignore feature owns.
+*
+* @see https://zed.dev/docs/ai/tool-permissions#supported-tools
+*/
+const ZED_EXCLUDED_CANONICAL_CATEGORIES = /* @__PURE__ */ new Set([
+	"read",
+	"grep",
+	"glob"
+]);
+/** The Zed-side spellings of the same tools, for a category that names one directly. */
+const ZED_EXCLUDED_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"read_file",
+	"grep",
+	"find_path",
+	"list_directory"
+]);
+const isZedExcludedCategory = (category) => ZED_EXCLUDED_CANONICAL_CATEGORIES.has(category) || ZED_EXCLUDED_TOOL_NAMES.has(toZedToolName(category));
 const ZED_TO_CANONICAL_TOOL_NAMES = Object.fromEntries(Object.entries(CANONICAL_TO_ZED_TOOL_NAMES).map(([k, v]) => [v, k]));
 function toZedToolName(canonical) {
 	return CANONICAL_TO_ZED_TOOL_NAMES[canonical] ?? canonical;
@@ -32416,15 +32720,21 @@ var ZedPermissions = class ZedPermissions extends ToolPermissions {
 		const existingTools = asRecord(toolPermissions.tools);
 		let managedDefault;
 		const managedTools = {};
+		const excludedCategories = [];
 		for (const [category, rules] of Object.entries(config.permission)) {
 			if (category === "*") {
 				for (const [pattern, action] of Object.entries(rules)) if (pattern === "*") managedDefault = CANONICAL_TO_ZED_ACTION[action];
 				else logger?.warn(`Zed permissions: dropping the "*" category rule for pattern "${pattern}" — Zed's global tool-permission default takes no patterns; scope the rule to a tool category instead.`);
 				continue;
 			}
+			if (isZedExcludedCategory(category)) {
+				if (Object.values(rules).some((action) => action === "deny" || action === "ask")) excludedCategories.push(category);
+				continue;
+			}
 			const tool = buildZedToolPermission(rules);
 			if (tool) managedTools[toZedToolName(category)] = tool;
 		}
+		if (excludedCategories.length > 0) logger?.warn(`Zed permissions: dropping the ${excludedCategories.map((category) => `"${category}"`).join(", ")} ${excludedCategories.length === 1 ? "category" : "categories"} — Zed does not gate its read-only tools, so the entries would never be consulted. Zed's read-denial surface is \`private_files\`, which the ignore feature writes from \`.rulesync/.aiignore\`.`);
 		const managedToolNames = new Set(Object.keys(managedTools));
 		if ("*" in config.permission) managedToolNames.add("*");
 		const preservedTools = Object.fromEntries(Object.entries(existingTools).filter(([toolName]) => !managedToolNames.has(toolName)));
@@ -33216,18 +33526,16 @@ var DirFeatureProcessor = class {
 				})) dirHasChanges = true;
 			}
 			const otherFiles = aiDir.getOtherFiles();
-			const otherFileContents = [];
 			for (const file of otherFiles) {
-				const contentWithNewline = addTrailingNewline(file.fileBuffer.toString("utf-8"));
-				otherFileContents.push(contentWithNewline);
-				if (!dirHasChanges) {
-					const filePath = (0, node_path.join)(dirPath, file.relativeFilePathToDirPath);
-					if (!fileContentsEquivalent({
-						filePath,
-						expected: contentWithNewline,
-						existing: await readFileContentOrNull(filePath)
-					})) dirHasChanges = true;
-				}
+				if (dirHasChanges) break;
+				const filePath = (0, node_path.join)(dirPath, file.relativeFilePathToDirPath);
+				const existingBuffer = await readFileBufferOrNull(filePath);
+				if (!companionFileContentsEquivalent({
+					filePath,
+					expected: file.fileBuffer,
+					existing: existingBuffer,
+					composed: file.composed
+				})) dirHasChanges = true;
 			}
 			if (!dirHasChanges) continue;
 			const relativeDir = aiDir.getRelativePathFromCwd();
@@ -33247,11 +33555,8 @@ var DirFeatureProcessor = class {
 					await writeFileContent((0, node_path.join)(dirPath, mainFile.name), mainFileContent);
 					changedPaths.push((0, node_path.join)(relativeDir, mainFile.name));
 				}
-				for (const [i, file] of otherFiles.entries()) {
-					const filePath = (0, node_path.join)(dirPath, file.relativeFilePathToDirPath);
-					const content = otherFileContents[i];
-					if (content === void 0) throw new Error(`Internal error: content for file ${file.relativeFilePathToDirPath} is undefined. This indicates a synchronization issue between otherFiles and otherFileContents arrays.`);
-					await writeFileContent(filePath, content);
+				for (const file of otherFiles) {
+					await writeFileBuffer((0, node_path.join)(dirPath, file.relativeFilePathToDirPath), file.fileBuffer);
 					changedPaths.push((0, node_path.join)(relativeDir, file.relativeFilePathToDirPath));
 				}
 			}
@@ -33977,6 +34282,39 @@ function buildClaudecodeSkillFrontmatter({ rulesyncFrontmatter, resolvedDisableM
 	return frontmatter;
 }
 /**
+* Escapes the glob metacharacters in a directory path so it matches literally.
+* A real directory name may contain them — `app/[slug]` in a Next.js tree is
+* the common case, and unescaped `[slug]` reads as a bracket expression that
+* matches a different subtree (or nothing at all).
+*
+* @see https://code.claude.com/docs/en/memory
+*/
+function escapeGlobLiteral(dirPath) {
+	return dirPath.replaceAll(/[\\*?[\]{}()!]/g, "\\$&");
+}
+/**
+* Claude Code scopes a nested skill by its location: a skill living in
+* `apps/web/.claude/skills/deploy` only activates while working under
+* `apps/web`. rulesync generates every imported skill into the project-root
+* `.claude/skills/`, so on import that location-based scoping has to be
+* re-expressed as an explicit `paths` glob — otherwise the round-trip silently
+* promotes a subtree skill to global activation.
+*
+* Returns the derived glob for a nested discovery root, or `undefined` for the
+* project-root `.claude/skills` (and for any root whose subtree cannot be
+* determined), where no scoping is implied.
+*
+* @see https://code.claude.com/docs/en/skills
+*/
+function deriveNestedSkillPaths(relativeDirPath) {
+	const posixDirPath = toPosixPath(relativeDirPath);
+	const skillsDirSuffix = `/${toPosixPath(CLAUDECODE_SKILLS_DIR_PATH)}`;
+	if (!posixDirPath.endsWith(skillsDirSuffix)) return;
+	const subtree = posixDirPath.slice(0, -skillsDirSuffix.length);
+	if (subtree === "" || subtree === ".") return;
+	return [`${escapeGlobLiteral(subtree)}/**`];
+}
+/**
 * Represents a Claude Code skill directory.
 * Unlike subagents and commands, skills are directories containing SKILL.md and other files.
 * Extends ToolSkill to inherit directory management and security features from AiDir.
@@ -34064,6 +34402,7 @@ var ClaudecodeSkill = class extends ToolSkill {
 	}
 	toRulesyncSkill() {
 		const frontmatter = this.getFrontmatter();
+		const resolvedPaths = frontmatter.paths !== void 0 ? frontmatter.paths : deriveNestedSkillPaths(this.relativeDirPath);
 		const claudecodeSection = {
 			...frontmatter.when_to_use && { when_to_use: frontmatter.when_to_use },
 			...frontmatter["allowed-tools"] && { "allowed-tools": frontmatter["allowed-tools"] },
@@ -34080,7 +34419,7 @@ var ClaudecodeSkill = class extends ToolSkill {
 			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] },
 			...frontmatter["user-invocable"] !== void 0 && { "user-invocable": frontmatter["user-invocable"] },
 			...this.relativeDirPath === CLAUDECODE_SCHEDULED_TASKS_DIR_PATH && { "scheduled-task": true },
-			...frontmatter.paths !== void 0 && { paths: frontmatter.paths }
+			...resolvedPaths !== void 0 && { paths: resolvedPaths }
 		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
@@ -34478,7 +34817,8 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 			fileBuffer: Buffer.from((0, js_yaml.dump)(openaiObject, {
 				lineWidth: -1,
 				noRefs: true
-			}))
+			})),
+			composed: true
 		}] : baseOtherFiles;
 		return new CodexCliSkill({
 			outputRoot,
@@ -34538,7 +34878,11 @@ const CopilotSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string(),
 	license: zod_mini.z.optional(zod_mini.z.string()),
-	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
+	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())])),
+	"argument-hint": zod_mini.z.optional(zod_mini.z.string()),
+	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
+	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
+	context: zod_mini.z.optional(zod_mini.z.string())
 });
 /**
 * Represents a GitHub Copilot skill directory.
@@ -34596,7 +34940,11 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 		const frontmatter = this.getFrontmatter();
 		const copilotSection = {
 			...frontmatter.license !== void 0 && { license: frontmatter.license },
-			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] }
+			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] },
+			...frontmatter["argument-hint"] !== void 0 && { "argument-hint": frontmatter["argument-hint"] },
+			...frontmatter["user-invocable"] !== void 0 && { "user-invocable": frontmatter["user-invocable"] },
+			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] },
+			...frontmatter.context !== void 0 && { context: frontmatter.context }
 		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
@@ -34618,11 +34966,24 @@ var CopilotSkill = class CopilotSkill extends ToolSkill {
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const settablePaths = CopilotSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const copilotSection = rulesyncFrontmatter.copilot;
+		const resolvedUserInvocable = resolveUserInvocable({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotSection
+		});
+		const resolvedDisableModelInvocation = resolveDisableModelInvocation({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotSection
+		});
 		const copilotFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
-			...rulesyncFrontmatter.copilot?.license !== void 0 && { license: rulesyncFrontmatter.copilot.license },
-			...rulesyncFrontmatter.copilot?.["allowed-tools"] !== void 0 && { "allowed-tools": rulesyncFrontmatter.copilot["allowed-tools"] }
+			...copilotSection?.license !== void 0 && { license: copilotSection.license },
+			...copilotSection?.["allowed-tools"] !== void 0 && { "allowed-tools": copilotSection["allowed-tools"] },
+			...copilotSection?.["argument-hint"] !== void 0 && { "argument-hint": copilotSection["argument-hint"] },
+			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
+			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation },
+			...copilotSection?.context !== void 0 && { context: copilotSection.context }
 		};
 		return new CopilotSkill({
 			outputRoot,
@@ -34769,14 +35130,23 @@ var CopilotcliSkill = class CopilotcliSkill extends ToolSkill {
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const settablePaths = CopilotcliSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const copilotcliSection = rulesyncFrontmatter.copilotcli;
+		const resolvedUserInvocable = resolveUserInvocable({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotcliSection
+		});
+		const resolvedDisableModelInvocation = resolveDisableModelInvocation({
+			rootFrontmatter: rulesyncFrontmatter,
+			section: copilotcliSection
+		});
 		const copilotcliFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
-			...rulesyncFrontmatter.copilotcli?.license !== void 0 && { license: rulesyncFrontmatter.copilotcli.license },
-			...rulesyncFrontmatter.copilotcli?.["allowed-tools"] !== void 0 && { "allowed-tools": rulesyncFrontmatter.copilotcli["allowed-tools"] },
-			...rulesyncFrontmatter.copilotcli?.["argument-hint"] !== void 0 && { "argument-hint": rulesyncFrontmatter.copilotcli["argument-hint"] },
-			...rulesyncFrontmatter.copilotcli?.["user-invocable"] !== void 0 && { "user-invocable": rulesyncFrontmatter.copilotcli["user-invocable"] },
-			...rulesyncFrontmatter.copilotcli?.["disable-model-invocation"] !== void 0 && { "disable-model-invocation": rulesyncFrontmatter.copilotcli["disable-model-invocation"] }
+			...copilotcliSection?.license !== void 0 && { license: copilotcliSection.license },
+			...copilotcliSection?.["allowed-tools"] !== void 0 && { "allowed-tools": copilotcliSection["allowed-tools"] },
+			...copilotcliSection?.["argument-hint"] !== void 0 && { "argument-hint": copilotcliSection["argument-hint"] },
+			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
+			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation }
 		};
 		return new CopilotcliSkill({
 			outputRoot,
@@ -35334,7 +35704,9 @@ const FactorydroidSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
 	description: zod_mini.z.string(),
 	"user-invocable": zod_mini.z.optional(zod_mini.z.boolean()),
-	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean())
+	"disable-model-invocation": zod_mini.z.optional(zod_mini.z.boolean()),
+	enabled: zod_mini.z.optional(zod_mini.z.boolean()),
+	"allowed-tools": zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.array(zod_mini.z.string())]))
 });
 /**
 * Represents a Factory Droid skill directory.
@@ -35390,7 +35762,9 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 		const frontmatter = this.getFrontmatter();
 		const factorydroidBlock = {
 			...frontmatter["disable-model-invocation"] !== void 0 && { "disable-model-invocation": frontmatter["disable-model-invocation"] },
-			...frontmatter["user-invocable"] !== void 0 && { "user-invocable": frontmatter["user-invocable"] }
+			...frontmatter["user-invocable"] !== void 0 && { "user-invocable": frontmatter["user-invocable"] },
+			...frontmatter.enabled !== void 0 && { enabled: frontmatter.enabled },
+			...frontmatter["allowed-tools"] !== void 0 && { "allowed-tools": frontmatter["allowed-tools"] }
 		};
 		const rulesyncFrontmatter = {
 			name: frontmatter.name,
@@ -35412,19 +35786,22 @@ var FactorydroidSkill = class FactorydroidSkill extends ToolSkill {
 	static fromRulesyncSkill({ outputRoot = process.cwd(), rulesyncSkill, validate = true, global = false }) {
 		const settablePaths = FactorydroidSkill.getSettablePaths({ global });
 		const rulesyncFrontmatter = rulesyncSkill.getFrontmatter();
+		const factorydroidSection = rulesyncFrontmatter.factorydroid;
 		const resolvedDisableModelInvocation = resolveDisableModelInvocation({
 			rootFrontmatter: rulesyncFrontmatter,
-			section: rulesyncFrontmatter.factorydroid
+			section: factorydroidSection
 		});
 		const resolvedUserInvocable = resolveUserInvocable({
 			rootFrontmatter: rulesyncFrontmatter,
-			section: rulesyncFrontmatter.factorydroid
+			section: factorydroidSection
 		});
 		const factorydroidFrontmatter = {
 			name: rulesyncFrontmatter.name,
 			description: rulesyncFrontmatter.description,
 			...resolvedDisableModelInvocation !== void 0 && { "disable-model-invocation": resolvedDisableModelInvocation },
-			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable }
+			...resolvedUserInvocable !== void 0 && { "user-invocable": resolvedUserInvocable },
+			...factorydroidSection?.enabled !== void 0 && { enabled: factorydroidSection.enabled },
+			...factorydroidSection?.["allowed-tools"] !== void 0 && { "allowed-tools": factorydroidSection["allowed-tools"] }
 		};
 		return new FactorydroidSkill({
 			outputRoot,
@@ -39445,7 +39822,17 @@ var ClaudecodeSubagent = class ClaudecodeSubagent extends ToolSubagent {
 			validate: true
 		});
 	}
-	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false }) {
+	/**
+	* Last chance to adjust the tool frontmatter before it is written. The base
+	* implementation only warns about names Claude Code rejects; plugin-scoped
+	* subclasses extend it to drop fields Claude Code refuses to honor for
+	* plugin-shipped agents.
+	*/
+	static sanitizeFrontmatter({ frontmatter, relativeFilePath, logger }) {
+		if (frontmatter.name.includes(":")) logger?.warn(`Claude Code will reject the subagent in ${relativeFilePath}: the name "${frontmatter.name}" contains ":", which is reserved for plugin namespacing.`);
+		return frontmatter;
+	}
+	static fromRulesyncSubagent({ outputRoot = process.cwd(), rulesyncSubagent, validate = true, global = false, logger }) {
 		const rulesyncFrontmatter = rulesyncSubagent.getFrontmatter();
 		const claudecodeSection = this.filterToolSpecificSection(rulesyncFrontmatter.claudecode ?? {}, ["name", "description"]);
 		const rawClaudecodeFrontmatter = {
@@ -39455,7 +39842,11 @@ var ClaudecodeSubagent = class ClaudecodeSubagent extends ToolSubagent {
 		};
 		const result = ClaudecodeSubagentFrontmatterSchema.safeParse(rawClaudecodeFrontmatter);
 		if (!result.success) throw new Error(`Invalid claudecode subagent frontmatter in ${rulesyncSubagent.getRelativeFilePath()}: ${formatError(result.error)}`);
-		const claudecodeFrontmatter = result.data;
+		const claudecodeFrontmatter = this.sanitizeFrontmatter({
+			frontmatter: result.data,
+			relativeFilePath: rulesyncSubagent.getRelativeFilePath(),
+			logger
+		});
 		const body = rulesyncSubagent.getBody();
 		const fileContent = stringifyFrontmatter(body, claudecodeFrontmatter);
 		const paths = this.getSettablePaths({ global });
@@ -39524,6 +39915,21 @@ var ClaudecodeSubagent = class ClaudecodeSubagent extends ToolSubagent {
 };
 //#endregion
 //#region src/features/subagents/claudecode-plugin-subagent.ts
+/**
+* Claude Code refuses these for plugin-shipped agents "for security reasons",
+* so emitting them leaves the author believing the agent is constrained when it
+* is not. Only these three are dropped: the other fields upstream does not list
+* (e.g. `color`) are merely ignored, with no misleading security posture.
+*
+* @see https://code.claude.com/docs/en/plugins-reference
+*/
+const PLUGIN_FORBIDDEN_FIELDS = [
+	"hooks",
+	"mcpServers",
+	"permissionMode"
+];
+/** The only `isolation` value plugin agents accept. */
+const PLUGIN_ISOLATION_VALUE = "worktree";
 var ClaudecodePluginSubagent = class extends ClaudecodeSubagent {
 	static isTargetedByRulesyncSubagent(rulesyncSubagent) {
 		const targets = rulesyncSubagent.getFrontmatter().targets;
@@ -39532,6 +39938,21 @@ var ClaudecodePluginSubagent = class extends ClaudecodeSubagent {
 	static getSettablePaths() {
 		return { relativeDirPath: CLAUDECODE_PLUGIN_AGENTS_DIR };
 	}
+	static sanitizeFrontmatter({ frontmatter, relativeFilePath, logger }) {
+		const sanitized = { ...super.sanitizeFrontmatter({
+			frontmatter,
+			relativeFilePath,
+			logger
+		}) };
+		const dropped = PLUGIN_FORBIDDEN_FIELDS.filter((field) => sanitized[field] !== void 0);
+		for (const field of PLUGIN_FORBIDDEN_FIELDS) delete sanitized[field];
+		if (dropped.length > 0) logger?.warn(`Dropping ${dropped.join(", ")} from claudecode-plugin subagent ${relativeFilePath}: Claude Code does not support these fields for plugin-shipped agents.`);
+		if (sanitized.isolation !== void 0 && sanitized.isolation !== PLUGIN_ISOLATION_VALUE) {
+			logger?.warn(`Dropping isolation "${sanitized.isolation}" from claudecode-plugin subagent ${relativeFilePath}: "${PLUGIN_ISOLATION_VALUE}" is the only value Claude Code accepts for plugin-shipped agents.`);
+			delete sanitized.isolation;
+		}
+		return sanitized;
+	}
 };
 //#endregion
 //#region src/features/subagents/cline-subagent.ts
@@ -43185,7 +43606,8 @@ var SubagentsProcessor = class extends FeatureProcessor {
 			outputRoot: this.outputRoot,
 			relativeDirPath: RulesyncSubagent.getSettablePaths().relativeDirPath,
 			rulesyncSubagent,
-			global: this.global
+			global: this.global,
+			logger: this.logger
 		}));
 	}
 	async convertToolFilesToRulesyncFiles(toolFiles) {
@@ -45138,7 +45560,7 @@ var CodexcliRule = class CodexcliRule extends ToolRule {
 };
 //#endregion
 //#region src/features/rules/copilot-rule.ts
-const CopilotRuleFrontmatterSchema = zod_mini.z.object({
+const CopilotRuleFrontmatterSchema = zod_mini.z.looseObject({
 	description: zod_mini.z.optional(zod_mini.z.string()),
 	applyTo: zod_mini.z.optional(zod_mini.z.string()),
 	name: zod_mini.z.optional(zod_mini.z.string()),
@@ -45194,15 +45616,13 @@ var CopilotRule = class CopilotRule extends ToolRule {
 	toRulesyncRule() {
 		let globs;
 		if (this.frontmatter.applyTo) globs = this.frontmatter.applyTo.split(",").map((g) => g.trim());
+		const { description, applyTo: _applyTo, ...copilotFields } = this.frontmatter;
 		const rulesyncFrontmatter = {
 			targets: ["*"],
 			root: this.isRoot(),
-			description: this.frontmatter.description,
+			description,
 			globs,
-			...(this.frontmatter.excludeAgent || this.frontmatter.name) && { copilot: {
-				...this.frontmatter.excludeAgent && { excludeAgent: this.frontmatter.excludeAgent },
-				...this.frontmatter.name && { name: this.frontmatter.name }
-			} }
+			...Object.keys(copilotFields).length > 0 && { copilot: copilotFields }
 		};
 		const relativeFilePath = this.getRelativeFilePath().replace(/\.instructions\.md$/, ".md");
 		return new RulesyncRule({
@@ -45219,10 +45639,9 @@ var CopilotRule = class CopilotRule extends ToolRule {
 		const root = rulesyncFrontmatter.root;
 		const paths = this.getSettablePaths({ global });
 		const copilotFrontmatter = {
+			...rulesyncFrontmatter.copilot,
 			description: rulesyncFrontmatter.description,
-			applyTo: rulesyncFrontmatter.globs?.length ? rulesyncFrontmatter.globs.join(",") : void 0,
-			excludeAgent: rulesyncFrontmatter.copilot?.excludeAgent,
-			name: rulesyncFrontmatter.copilot?.name
+			applyTo: rulesyncFrontmatter.globs?.length ? rulesyncFrontmatter.globs.join(",") : void 0
 		};
 		const body = rulesyncRule.getBody();
 		if (root) return new CopilotRule({
@@ -51621,6 +52040,12 @@ Object.defineProperty(exports, "warnOnConflictingFlags", {
 		return warnOnConflictingFlags;
 	}
 });
+Object.defineProperty(exports, "writeFileBuffer", {
+	enumerable: true,
+	get: function() {
+		return writeFileBuffer;
+	}
+});
 Object.defineProperty(exports, "writeFileContent", {
 	enumerable: true,
 	get: function() {