rulesync 16.34.2 → 16.35.0

package/dist/{import-D50FT0lm.cjs → import-j_cW_K5C.cjs}

@@ -540,6 +540,7 @@ const rulesProcessorToolTargetTuple = [
 	"musecode",
 	"opencode",
 	"pi",
+	"pool",
 	"qwencode",
 	"reasonix",
 	"replit",
@@ -553,7 +554,6 @@ const rulesProcessorToolTargetTuple = [
 	"zcode",
 	"zed",
 	"zoocode",
-	"pool",
 	"dsh"
 ];
 const ignoreProcessorToolTargetTuple = [
@@ -4116,6 +4116,10 @@ const HookDefinitionSchema = zod_mini.z.looseObject({
 	model: zod_mini.z.optional(safeString),
 	args: zod_mini.z.optional(zod_mini.z.array(safeString)),
 	metadata: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	source: zod_mini.z.optional(zod_mini.z.looseObject({
+		source: safeString,
+		ref: zod_mini.z.optional(safeString)
+	})),
 	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)())),
@@ -4876,10 +4880,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 = [
@@ -4887,6 +4893,8 @@ const BOB_HOOK_EVENTS = [
 	"beforeSubmitPrompt",
 	"preToolUse",
 	"postToolUse",
+	"preCompact",
+	"postCompact",
 	"stop"
 ];
 const CANONICAL_TO_BOB_EVENT_NAMES = {
@@ -4894,6 +4902,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]));
@@ -7305,13 +7315,30 @@ const DeepagentsExtensionsOverrideSchema = zod_mini.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 = zod_mini.z.looseObject({ disabled_project_servers: zod_mini.z.optional(zod_mini.z.array(zod_mini.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 = zod_mini.z.looseObject({
 	permission: zod_mini.z.optional(ToolScopedPermissionSchema),
 	startup: zod_mini.z.optional(DeepagentsStartupOverrideSchema),
-	extensions: zod_mini.z.optional(DeepagentsExtensionsOverrideSchema)
+	extensions: zod_mini.z.optional(DeepagentsExtensionsOverrideSchema),
+	mcp: zod_mini.z.optional(DeepagentsMcpOverrideSchema)
 });
 /**
 * The actions Junie's allowlist accepts. Verified against the shipped Junie
@@ -9625,7 +9652,13 @@ const RulesyncSkillFrontmatterSchema = zod_mini.z.looseObject({
 		"user-invocable": 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())]))
 	})),
-	commandcode: zod_mini.z.optional(zod_mini.z.looseObject({})),
+	commandcode: zod_mini.z.optional(zod_mini.z.looseObject({
+		license: zod_mini.z.optional(zod_mini.z.string()),
+		compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
+		metadata: 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())
+	})),
 	cortexcode: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	continue: zod_mini.z.optional(zod_mini.z.looseObject({})),
 	tabnine: zod_mini.z.optional(zod_mini.z.looseObject({})),
@@ -9869,7 +9902,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.
 *
@@ -9888,7 +9921,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.
 *
@@ -15456,6 +15489,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 = (0, node_path.join)(COMMANDCODE_DIR, "commands");
@@ -20670,6 +20704,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 }) {
@@ -20810,6 +20856,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`
@@ -20844,11 +20891,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);
@@ -20856,13 +20909,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
@@ -20968,6 +21030,14 @@ function emitAllPassthroughFields({ def, hookType, eventName, converterConfig, w
 			fields: converterConfig.recordPassthroughFields ?? [],
 			isValid: isEmittableRecord,
 			warn
+		}),
+		...emitPassthroughFields({
+			def,
+			hookType,
+			eventName,
+			fields: converterConfig.objectPassthroughFields ?? [],
+			isValid: isEmittableObject,
+			warn
 		})
 	};
 }
@@ -20991,9 +21061,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,
@@ -21115,6 +21188,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");
@@ -21280,6 +21367,14 @@ function importAllPassthroughFields({ h, hookType, converterConfig, warn }) {
 			isValid: isEmittableRecord,
 			describeInvalid: describeInvalidRecord,
 			warn
+		}),
+		...importPassthroughFields({
+			h,
+			hookType,
+			fields: converterConfig.objectPassthroughFields ?? [],
+			isValid: isImportableObject,
+			describeInvalid: describeInvalidObject,
+			warn
 		})
 	};
 }
@@ -21287,7 +21382,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,
@@ -21296,7 +21394,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",
@@ -21429,7 +21530,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) {
@@ -21914,6 +22018,7 @@ const AUGMENTCODE_CONVERTER_CONFIG = {
 		"beforeSubmitPrompt"
 	]),
 	supportedHookTypes: /* @__PURE__ */ new Set(["command"]),
+	timeoutUnit: "milliseconds",
 	arrayPassthroughFields: [{
 		canonical: "args",
 		tool: "args"
@@ -22512,9 +22617,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
 	}
 };
@@ -22525,10 +22633,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 {
@@ -23958,6 +24069,11 @@ const CORTEXCODE_SPEC = {
 		booleanPassthroughFields: [{
 			canonical: "enabled",
 			tool: "enabled"
+		}],
+		objectPassthroughFields: [{
+			canonical: "source",
+			tool: "source",
+			commandOnly: true
 		}]
 	}
 };
@@ -23968,8 +24084,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).
@@ -28615,7 +28732,7 @@ const toolHooksFactories = /* @__PURE__ */ new Map([
 			supportsImport: true
 		},
 		supportedEvents: BOB_HOOK_EVENTS,
-		supportedHookTypes: ["command"],
+		supportedHookTypes: ["command", "http"],
 		supportsMatcher: true,
 		matcherEvents: ["preToolUse", "postToolUse"]
 	}],
@@ -31429,6 +31546,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
@@ -31451,7 +31612,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
@@ -31517,10 +31680,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;
@@ -31530,9 +31699,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 {};
@@ -31553,6 +31723,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;
@@ -32577,7 +32748,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.
 *
@@ -32613,6 +32787,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) {
@@ -32640,6 +32825,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 }) {
@@ -32660,6 +32851,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;
 }
 /**
@@ -45158,6 +45355,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 = /[*?[\]]/;
@@ -45230,7 +45448,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
@@ -45328,17 +45548,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
 		});
@@ -45370,10 +45582,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({
@@ -45481,7 +45698,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) {
@@ -45494,7 +45711,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;
 }
 /**
@@ -45542,6 +45759,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
@@ -45590,6 +45838,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]`.
 */
@@ -45623,6 +45903,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.
 */
@@ -57375,7 +57689,12 @@ var CodexCliSkill = class CodexCliSkill extends ToolSkill {
 //#region src/features/skills/commandcode-skill.ts
 const CommandcodeSkillFrontmatterSchema = zod_mini.z.looseObject({
 	name: zod_mini.z.string(),
-	description: zod_mini.z.string()
+	description: zod_mini.z.string(),
+	license: zod_mini.z.optional(zod_mini.z.string()),
+	compatibility: zod_mini.z.optional(zod_mini.z.union([zod_mini.z.string(), zod_mini.z.looseObject({})])),
+	metadata: 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())
 });
 /**
 * Represents a Command Code skill directory.
@@ -57458,10 +57777,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,
@@ -64834,6 +65178,35 @@ const CommandcodeSubagentFrontmatterSchema = zod_mini.z.looseObject({
 	showOutput: zod_mini.z.optional(zod_mini.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.
@@ -64880,7 +65253,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 = {
@@ -64888,6 +65261,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 });
@@ -71260,8 +71638,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
 	*/
@@ -71336,9 +71718,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,
@@ -76029,6 +76411,15 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			collisionPolicy: "fold"
 		}
 	}],
+	["pool", {
+		class: PoolRule,
+		meta: {
+			extension: "md",
+			supportsGlobal: true,
+			ruleDiscoveryMode: "auto",
+			collisionPolicy: "fold"
+		}
+	}],
 	["qwencode", {
 		class: QwencodeRule,
 		meta: {
@@ -76152,15 +76543,6 @@ const toolRuleFactories = /* @__PURE__ */ new Map([
 			ruleDiscoveryMode: "auto"
 		}
 	}],
-	["pool", {
-		class: PoolRule,
-		meta: {
-			extension: "md",
-			supportsGlobal: true,
-			ruleDiscoveryMode: "auto",
-			collisionPolicy: "fold"
-		}
-	}],
 	["dsh", {
 		class: DshRule,
 		meta: {
@@ -79442,6 +79824,18 @@ Object.defineProperty(exports, "CODEXCLI_DIR", {
 		return CODEXCLI_DIR;
 	}
 });
+Object.defineProperty(exports, "COMMANDCODE_DIR", {
+	enumerable: true,
+	get: function() {
+		return COMMANDCODE_DIR;
+	}
+});
+Object.defineProperty(exports, "COMMANDCODE_SETTINGS_LOCAL_FILE_NAME", {
+	enumerable: true,
+	get: function() {
+		return COMMANDCODE_SETTINGS_LOCAL_FILE_NAME;
+	}
+});
 Object.defineProperty(exports, "CONFLICTING_TARGET_PAIRS", {
 	enumerable: true,
 	get: function() {