@hasna/instructions 0.4.39 → 0.4.42

package/dist/cli/index.js

@@ -20,14 +20,12 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  if (mod && typeof mod === "object" || typeof mod === "function") {
-    for (let key of __getOwnPropNames(mod))
-      if (!__hasOwnProp.call(to, key))
-        __defProp(to, key, {
-          get: __accessProp.bind(mod, key),
-          enumerable: true
-        });
-  }
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -50,7 +48,7 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/error.js
-var require_error = __commonJS(function(exports) {
+var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
       super(message);
@@ -74,7 +72,7 @@ var require_error = __commonJS(function(exports) {
 });
 
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/argument.js
-var require_argument = __commonJS(function(exports) {
+var require_argument = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
   class Argument {
@@ -153,7 +151,7 @@ var require_argument = __commonJS(function(exports) {
 });
 
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/help.js
-var require_help = __commonJS(function(exports) {
+var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
   class Help {
@@ -503,7 +501,7 @@ ${itemIndentStr}`);
 });
 
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/option.js
-var require_option = __commonJS(function(exports) {
+var require_option = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
   class Option {
@@ -681,7 +679,7 @@ var require_option = __commonJS(function(exports) {
 });
 
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar = __commonJS(function(exports) {
+var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
     if (Math.abs(a.length - b.length) > maxDistance)
@@ -754,7 +752,7 @@ var require_suggestSimilar = __commonJS(function(exports) {
 });
 
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/lib/command.js
-var require_command = __commonJS(function(exports) {
+var require_command = __commonJS((exports) => {
   var EventEmitter = __require("events").EventEmitter;
   var childProcess = __require("child_process");
   var path = __require("path");
@@ -2064,7 +2062,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 });
 
 // ../../node_modules/.bun/commander@13.1.0/node_modules/commander/index.js
-var require_commander = __commonJS(function(exports) {
+var require_commander = __commonJS((exports) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
   var { CommanderError, InvalidArgumentError } = require_error();
@@ -2592,11 +2590,11 @@ var init_configs = __esm(() => {
 // src/lib/template.ts
 var exports_template = {};
 __export(exports_template, {
-  extractTemplateVars: () => extractTemplateVars,
-  isTemplate: () => isTemplate,
-  parseTemplateVars: () => parseTemplateVars,
+  renderTemplatePreview: () => renderTemplatePreview,
   renderTemplate: () => renderTemplate,
-  renderTemplatePreview: () => renderTemplatePreview
+  parseTemplateVars: () => parseTemplateVars,
+  isTemplate: () => isTemplate,
+  extractTemplateVars: () => extractTemplateVars
 });
 function parseTemplateVars(content) {
   const names = new Set;
@@ -6956,113 +6954,113 @@ var init_types2 = __esm(() => {
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
-  BRAND: () => BRAND,
-  DIRTY: () => DIRTY,
-  EMPTY_PATH: () => EMPTY_PATH,
-  INVALID: () => INVALID,
-  NEVER: () => NEVER,
-  OK: () => OK,
-  ParseStatus: () => ParseStatus,
-  Schema: () => ZodType,
-  ZodAny: () => ZodAny,
-  ZodArray: () => ZodArray,
-  ZodBigInt: () => ZodBigInt,
-  ZodBoolean: () => ZodBoolean,
-  ZodBranded: () => ZodBranded,
-  ZodCatch: () => ZodCatch,
-  ZodDate: () => ZodDate,
-  ZodDefault: () => ZodDefault,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodEffects: () => ZodEffects,
-  ZodEnum: () => ZodEnum,
-  ZodError: () => ZodError,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFunction: () => ZodFunction,
-  ZodIntersection: () => ZodIntersection,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodLazy: () => ZodLazy,
-  ZodLiteral: () => ZodLiteral,
-  ZodMap: () => ZodMap,
-  ZodNaN: () => ZodNaN,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNever: () => ZodNever,
-  ZodNull: () => ZodNull,
-  ZodNullable: () => ZodNullable,
-  ZodNumber: () => ZodNumber,
-  ZodObject: () => ZodObject,
-  ZodOptional: () => ZodOptional,
-  ZodParsedType: () => ZodParsedType,
-  ZodPipeline: () => ZodPipeline,
-  ZodPromise: () => ZodPromise,
-  ZodReadonly: () => ZodReadonly,
-  ZodRecord: () => ZodRecord,
-  ZodSchema: () => ZodType,
-  ZodSet: () => ZodSet,
-  ZodString: () => ZodString,
-  ZodSymbol: () => ZodSymbol,
-  ZodTransformer: () => ZodEffects,
-  ZodTuple: () => ZodTuple,
-  ZodType: () => ZodType,
-  ZodUndefined: () => ZodUndefined,
-  ZodUnion: () => ZodUnion,
-  ZodUnknown: () => ZodUnknown,
-  ZodVoid: () => ZodVoid,
-  addIssueToContext: () => addIssueToContext,
-  any: () => anyType,
-  array: () => arrayType,
-  bigint: () => bigIntType,
-  boolean: () => booleanType,
-  coerce: () => coerce,
-  custom: () => custom,
-  date: () => dateType,
-  datetimeRegex: () => datetimeRegex,
-  defaultErrorMap: () => en_default,
-  discriminatedUnion: () => discriminatedUnionType,
-  effect: () => effectsType,
-  enum: () => enumType,
-  function: () => functionType,
-  getErrorMap: () => getErrorMap,
-  getParsedType: () => getParsedType,
-  instanceof: () => instanceOfType,
-  intersection: () => intersectionType,
-  isAborted: () => isAborted,
-  isAsync: () => isAsync,
-  isDirty: () => isDirty,
-  isValid: () => isValid,
-  late: () => late,
-  lazy: () => lazyType,
-  literal: () => literalType,
-  makeIssue: () => makeIssue,
-  map: () => mapType,
-  nan: () => nanType,
-  nativeEnum: () => nativeEnumType,
-  never: () => neverType,
-  null: () => nullType,
-  nullable: () => nullableType,
-  number: () => numberType,
-  object: () => objectType,
-  objectUtil: () => objectUtil,
-  oboolean: () => oboolean,
-  onumber: () => onumber,
-  optional: () => optionalType,
-  ostring: () => ostring,
-  pipeline: () => pipelineType,
-  preprocess: () => preprocessType,
-  promise: () => promiseType,
-  quotelessJson: () => quotelessJson,
-  record: () => recordType,
-  set: () => setType,
-  setErrorMap: () => setErrorMap,
-  strictObject: () => strictObjectType,
-  string: () => stringType,
-  symbol: () => symbolType,
-  transformer: () => effectsType,
-  tuple: () => tupleType,
-  undefined: () => undefinedType,
-  union: () => unionType,
-  unknown: () => unknownType,
+  void: () => voidType,
   util: () => util,
-  void: () => voidType
+  unknown: () => unknownType,
+  union: () => unionType,
+  undefined: () => undefinedType,
+  tuple: () => tupleType,
+  transformer: () => effectsType,
+  symbol: () => symbolType,
+  string: () => stringType,
+  strictObject: () => strictObjectType,
+  setErrorMap: () => setErrorMap,
+  set: () => setType,
+  record: () => recordType,
+  quotelessJson: () => quotelessJson,
+  promise: () => promiseType,
+  preprocess: () => preprocessType,
+  pipeline: () => pipelineType,
+  ostring: () => ostring,
+  optional: () => optionalType,
+  onumber: () => onumber,
+  oboolean: () => oboolean,
+  objectUtil: () => objectUtil,
+  object: () => objectType,
+  number: () => numberType,
+  nullable: () => nullableType,
+  null: () => nullType,
+  never: () => neverType,
+  nativeEnum: () => nativeEnumType,
+  nan: () => nanType,
+  map: () => mapType,
+  makeIssue: () => makeIssue,
+  literal: () => literalType,
+  lazy: () => lazyType,
+  late: () => late,
+  isValid: () => isValid,
+  isDirty: () => isDirty,
+  isAsync: () => isAsync,
+  isAborted: () => isAborted,
+  intersection: () => intersectionType,
+  instanceof: () => instanceOfType,
+  getParsedType: () => getParsedType,
+  getErrorMap: () => getErrorMap,
+  function: () => functionType,
+  enum: () => enumType,
+  effect: () => effectsType,
+  discriminatedUnion: () => discriminatedUnionType,
+  defaultErrorMap: () => en_default,
+  datetimeRegex: () => datetimeRegex,
+  date: () => dateType,
+  custom: () => custom,
+  coerce: () => coerce,
+  boolean: () => booleanType,
+  bigint: () => bigIntType,
+  array: () => arrayType,
+  any: () => anyType,
+  addIssueToContext: () => addIssueToContext,
+  ZodVoid: () => ZodVoid,
+  ZodUnknown: () => ZodUnknown,
+  ZodUnion: () => ZodUnion,
+  ZodUndefined: () => ZodUndefined,
+  ZodType: () => ZodType,
+  ZodTuple: () => ZodTuple,
+  ZodTransformer: () => ZodEffects,
+  ZodSymbol: () => ZodSymbol,
+  ZodString: () => ZodString,
+  ZodSet: () => ZodSet,
+  ZodSchema: () => ZodType,
+  ZodRecord: () => ZodRecord,
+  ZodReadonly: () => ZodReadonly,
+  ZodPromise: () => ZodPromise,
+  ZodPipeline: () => ZodPipeline,
+  ZodParsedType: () => ZodParsedType,
+  ZodOptional: () => ZodOptional,
+  ZodObject: () => ZodObject,
+  ZodNumber: () => ZodNumber,
+  ZodNullable: () => ZodNullable,
+  ZodNull: () => ZodNull,
+  ZodNever: () => ZodNever,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNaN: () => ZodNaN,
+  ZodMap: () => ZodMap,
+  ZodLiteral: () => ZodLiteral,
+  ZodLazy: () => ZodLazy,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodIntersection: () => ZodIntersection,
+  ZodFunction: () => ZodFunction,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodError: () => ZodError,
+  ZodEnum: () => ZodEnum,
+  ZodEffects: () => ZodEffects,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodDefault: () => ZodDefault,
+  ZodDate: () => ZodDate,
+  ZodCatch: () => ZodCatch,
+  ZodBranded: () => ZodBranded,
+  ZodBoolean: () => ZodBoolean,
+  ZodBigInt: () => ZodBigInt,
+  ZodArray: () => ZodArray,
+  ZodAny: () => ZodAny,
+  Schema: () => ZodType,
+  ParseStatus: () => ParseStatus,
+  OK: () => OK,
+  NEVER: () => NEVER,
+  INVALID: () => INVALID,
+  EMPTY_PATH: () => EMPTY_PATH,
+  DIRTY: () => DIRTY,
+  BRAND: () => BRAND
 });
 var init_external = __esm(() => {
   init_errors();
@@ -11463,16 +11461,50 @@ function indexHeader(tool, profile) {
   ].join(`
 `);
 }
-function buildNativeImportFiles(targetHome, adapter, profile, sources) {
+function isCompiledClaudeGlobSource(adapter, source, providerVersion) {
+  if (adapter.tool !== "claude")
+    return false;
+  if (providerVersion && !providerVersionSatisfies(providerVersion, CLAUDE_PATHS_RULES_VERSION_RANGE))
+    return false;
+  const compiledBinding = source.provenance?.["profileBinding"];
+  if (!compiledBinding || typeof compiledBinding !== "object")
+    return false;
+  const activation = source.metadata?.["activation"];
+  return activation?.mode === "glob";
+}
+function claudeGlobRuleFile(targetHome, index, source) {
+  const globs = source.globs ?? [];
+  if (globs.length === 0)
+    throw new Error(`Claude glob source ${source.id} has no paths.`);
+  const n = String(index + 1).padStart(2, "0");
+  const relativePath = posix2.join("rules", `${n}-${source.normalizedId}.md`);
+  const content = [
+    "---",
+    "paths:",
+    ...globs.map((glob) => `  - ${yamlQuote2(glob)}`),
+    "---",
+    "",
+    sectionForSource(source),
+    ...source.resolvedRules.flatMap((rule) => ["", sectionForRule(source, rule)])
+  ].join(`
+`);
+  return makeFile(targetHome, relativePath, "rule", content, [source.id, ...source.resolvedRules.map((rule) => rule.id)]);
+}
+function buildNativeImportFiles(targetHome, adapter, profile, sources, providerVersion) {
   const indexFile = adapter.indexFile;
-  const fragments = sources.flatMap((source, index2) => [
-    makeFile(targetHome, fragmentPath(adapter, index2, source), "fragment", sectionForSource(source), [source.id]),
-    ...source.resolvedRules.map((rule) => makeFile(targetHome, ruleFragmentPath(adapter, source, rule), "rule", sectionForRule(source, rule), [source.id, rule.id]))
-  ]);
+  const fragments = sources.flatMap((source, index2) => {
+    if (isCompiledClaudeGlobSource(adapter, source, providerVersion))
+      return [];
+    return [
+      makeFile(targetHome, fragmentPath(adapter, index2, source), "fragment", sectionForSource(source), [source.id]),
+      ...source.resolvedRules.map((rule) => makeFile(targetHome, ruleFragmentPath(adapter, source, rule), "rule", sectionForRule(source, rule), [source.id, rule.id]))
+    ];
+  });
+  const conditionalRules = sources.flatMap((source, index2) => isCompiledClaudeGlobSource(adapter, source, providerVersion) ? [claudeGlobRuleFile(targetHome, index2, source)] : []);
   const imports = fragments.map((file) => `@${importPath(indexFile, file.relativePath)}`);
   const index = makeFile(targetHome, indexFile, "index", [indexHeader(adapter.tool, profile), ...imports].join(`
 `), sources.map((source) => source.id));
-  return [index, ...fragments];
+  return [index, ...fragments, ...conditionalRules];
 }
 function buildFlattenedMarkdownFiles(targetHome, adapter, profile, sources) {
   const content = [
@@ -11660,10 +11692,10 @@ function makeAntigravityRuleFile(targetHome, relativePath, content, sourceIds) {
   }
   return file;
 }
-function buildFiles(targetHome, adapter, profile, sources, providerConfig) {
+function buildFiles(targetHome, adapter, profile, sources, providerConfig, providerVersion) {
   switch (adapter.mode) {
     case "native-imports":
-      return buildNativeImportFiles(targetHome, adapter, profile, sources);
+      return buildNativeImportFiles(targetHome, adapter, profile, sources, providerVersion);
     case "flattened-markdown":
       return buildFlattenedMarkdownFiles(targetHome, adapter, profile, sources);
     case "cursor-mdc":
@@ -11910,7 +11942,7 @@ function planSessionRender(input) {
   if (input.providerConfig && input.tool !== "opencode") {
     throw new Error("Provider base config is supported only for OpenCode session renders.");
   }
-  const baseFiles = blocked ? [] : buildFiles(targetHome, adapter, input.profile, orderedSources, input.providerConfig);
+  const baseFiles = blocked ? [] : buildFiles(targetHome, adapter, input.profile, orderedSources, input.providerConfig, input.provider_version);
   const projectContext = blocked ? null : composeProjectContextSessionRender({
     tool: input.tool,
     adapter_mode: adapter.mode,
@@ -12410,7 +12442,7 @@ function asStringArray(value) {
     return [];
   return value.filter((item) => typeof item === "string");
 }
-var ANTIGRAVITY_RULE_FILE_CHAR_LIMIT = 12000, SESSION_RENDERER_OWNER_ID = "instructions-session-renderer", SESSION_RENDER_TOOLS, SESSION_RENDER_PROFILE_ENTRYPOINTS, SESSION_RENDER_OWNED_CONFIG_TARGETS, IDENTITY_EXPORT_AUTHORITY, CODEWITH_PROTECTED_REPLACEMENT_TARGETS, CODEWITH_FLATTENED_ADAPTER, CODEWITH_NATIVE_ADAPTER, SESSION_TOOL_ADAPTERS, SESSION_RENDER_MANAGED_DIRS, SESSION_RENDER_SHARED_MANAGED_DIRS, SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS, SESSION_LAYER_RANK, CANONICAL_IDENTITY_EXPORT_PACKAGES;
+var ANTIGRAVITY_RULE_FILE_CHAR_LIMIT = 12000, SESSION_RENDERER_OWNER_ID = "instructions-session-renderer", SESSION_RENDER_TOOLS, SESSION_RENDER_PROFILE_ENTRYPOINTS, SESSION_RENDER_OWNED_CONFIG_TARGETS, IDENTITY_EXPORT_AUTHORITY, CODEWITH_PROTECTED_REPLACEMENT_TARGETS, CODEWITH_FLATTENED_ADAPTER, CODEWITH_NATIVE_ADAPTER, SESSION_TOOL_ADAPTERS, SESSION_RENDER_MANAGED_DIRS, SESSION_RENDER_SHARED_MANAGED_DIRS, SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS, SESSION_LAYER_RANK, CLAUDE_PATHS_RULES_VERSION_RANGE = ">=2.1.84", CANONICAL_IDENTITY_EXPORT_PACKAGES;
 var init_session_render = __esm(() => {
   init_global_agent_rules_standard();
   init_codewith_shared_todos_storage_standard();
@@ -12933,7 +12965,6 @@ function planProfileSessionRender(input) {
   });
   const {
     profile_id: _profileId,
-    provider_version: _providerVersion,
     configs: _configs,
     bindings: _bindings,
     asset_configs: _assetConfigs,
@@ -13103,7 +13134,12 @@ var init_instruction_graph = __esm(() => {
   init_asset_plan();
   COMMON_FALLBACKS = ["fail", "flatten", "promote-always", "omit"];
   DEFAULT_PROVIDER_CAPABILITIES = Object.freeze({
-    claude: capability("claude", ">=1.0.0", "native-import", "CLAUDE.md @ imports", { native_imports: true, asset_surface: "code" }),
+    claude: capability("claude", ">=1.0.0", "native-import", "CLAUDE.md @ imports plus path-gated rules", {
+      activation_modes: ["always", "glob"],
+      native_imports: true,
+      conditional_artifacts: true,
+      asset_surface: "code"
+    }),
     codex: capability("codex", ">=0.1.0", "flattened", "AGENTS.md", { asset_surface: "cli" }),
     cursor: capability("cursor", ">=1.0.0", "cursor-rule", ".cursor/rules/*.mdc", { activation_modes: ["always", "glob"], conditional_artifacts: true, asset_surface: "ide" }),
     opencode: capability("opencode", ">=1.0.0", "managed-fragment", "opencode.json instructions", { provider_variant: "v1-instructions", session_surface: "opencode-config-instructions" }),
@@ -14059,13 +14095,13 @@ var init_session_render_ownership = __esm(() => {
 // src/lib/apply.ts
 var exports_apply = {};
 __export(exports_apply, {
-  applyConfig: () => applyConfig,
-  applyConfigs: () => applyConfigs,
-  applyConfigsWithReport: () => applyConfigsWithReport,
-  expandPath: () => expandPath,
-  getConfigHome: () => getConfigHome,
+  previewConfigs: () => previewConfigs,
   normalizeTargetPath: () => normalizeTargetPath,
-  previewConfigs: () => previewConfigs
+  getConfigHome: () => getConfigHome,
+  expandPath: () => expandPath,
+  applyConfigsWithReport: () => applyConfigsWithReport,
+  applyConfigs: () => applyConfigs,
+  applyConfig: () => applyConfig
 });
 import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "fs";
 import { basename as basename4, dirname as dirname4, join as join10, resolve as resolve7 } from "path";
@@ -14592,18 +14628,18 @@ var init_sync_dir = __esm(() => {
 // src/lib/sync.ts
 var exports_sync = {};
 __export(exports_sync, {
-  CLAUDE_PROMPT_OUTPUTS: () => CLAUDE_PROMPT_OUTPUTS,
-  KNOWN_CONFIGS: () => KNOWN_CONFIGS,
-  PROJECT_CONFIG_FILES: () => PROJECT_CONFIG_FILES,
-  detectAgent: () => detectAgent,
-  detectCategory: () => detectCategory,
-  detectFormat: () => detectFormat,
-  diffConfig: () => diffConfig,
-  syncFromDir: () => syncFromDir,
-  syncKnown: () => syncKnown,
-  syncProject: () => syncProject,
+  syncToDisk: () => syncToDisk,
   syncToDir: () => syncToDir,
-  syncToDisk: () => syncToDisk
+  syncProject: () => syncProject,
+  syncKnown: () => syncKnown,
+  syncFromDir: () => syncFromDir,
+  diffConfig: () => diffConfig,
+  detectFormat: () => detectFormat,
+  detectCategory: () => detectCategory,
+  detectAgent: () => detectAgent,
+  PROJECT_CONFIG_FILES: () => PROJECT_CONFIG_FILES,
+  KNOWN_CONFIGS: () => KNOWN_CONFIGS,
+  CLAUDE_PROMPT_OUTPUTS: () => CLAUDE_PROMPT_OUTPUTS
 });
 import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync8 } from "fs";
 import { basename as basename5, extname as extname3, join as join12 } from "path";
@@ -17551,21 +17587,24 @@ function planFileResult(plan, file, targetHome, previousHashes, previousManifest
 function assertNotSilentManagedWipeout(plan, results) {
   if (plan.allowEmptySources)
     return;
-  const managedDir = plan.adapter.managedDir;
-  const underManagedDir = (relativePath) => relativePath === managedDir || relativePath.startsWith(`${managedDir}/`);
-  const staleDeletions = results.filter((result) => result.action === "delete" && underManagedDir(result.relativePath));
+  const staleDeletions = results.filter((result) => result.action === "delete" && isPlanManagedFile(plan, result.relativePath, result.role));
   if (staleDeletions.length === 0)
     return;
-  const managedRetained = results.some((result) => result.action !== "delete" && underManagedDir(result.relativePath));
+  const managedRetained = results.some((result) => result.action !== "delete" && isPlanManagedFile(plan, result.relativePath, result.role));
   if (managedRetained)
     return;
-  throw new SessionApplyError(`Session render plan for ${plan.tool} (${plan.adapter.mode}) would delete ${staleDeletions.length} ` + `previously managed file(s) under "${managedDir}" and create or update none there: ` + `${staleDeletions.map((result) => result.relativePath).join(", ")}. ` + "Pass --allow-empty-sources only for explicit empty renders.");
+  throw new SessionApplyError(`Session render plan for ${plan.tool} (${plan.adapter.mode}) would delete ${staleDeletions.length} ` + "previously managed file(s) and create or update none: " + `${staleDeletions.map((result) => result.relativePath).join(", ")}. ` + "Pass --allow-empty-sources only for explicit empty renders.");
+}
+function isPlanManagedFile(plan, relativePath, role) {
+  const managedDir = plan.adapter.managedDir;
+  if (relativePath === managedDir || relativePath.startsWith(`${managedDir}/`))
+    return true;
+  return plan.tool === "claude" && role === "rule" && relativePath.startsWith("rules/");
 }
 function planStaleFileResults(plan, targetHome, previousManifest, currentRelativePaths, options) {
   if (!previousManifest)
     return [];
-  const managedPrefix = `${plan.adapter.managedDir}/`;
-  return previousManifest.files.filter((file) => !currentRelativePaths.has(file.relativePath)).filter((file) => file.relativePath === plan.adapter.managedDir || file.relativePath.startsWith(managedPrefix)).map((file) => planStaleFileResult(file, targetHome, options)).filter((result) => result !== null);
+  return previousManifest.files.filter((file) => !currentRelativePaths.has(file.relativePath)).filter((file) => isPlanManagedFile(plan, file.relativePath, file.role)).map((file) => planStaleFileResult(file, targetHome, options)).filter((result) => result !== null);
 }
 function planStaleFileResult(file, targetHome, options) {
   const target = resolveManifestRelativePath(file.relativePath, targetHome);