@hasna/instructions 0.4.39 → 0.4.43

package/dist/index.js

@@ -1060,113 +1060,113 @@ import { basename, dirname, isAbsolute, join as join4, parse, relative, resolve
 // ../../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
 });
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
@@ -8138,10 +8138,6 @@ function applyTransform(source, output, context = {}) {
   }
 }
 
-// src/lib/asset-plan.ts
-import { createHash as createHash3 } from "crypto";
-import { isAbsolute as isAbsolute2, posix, resolve as resolve3 } from "path";
-
 // src/lib/provider-version.ts
 function providerVersionSatisfies(version, range) {
   const current = parseProviderVersion(version);
@@ -8186,6 +8182,8 @@ function compareProviderVersions(left, right) {
 }
 
 // src/lib/asset-plan.ts
+import { createHash as createHash3 } from "crypto";
+import { isAbsolute as isAbsolute2, posix, resolve as resolve3 } from "path";
 var ASSET_PLAN_SCHEMA = "hasna.instructions.asset-plan/v1";
 var ASSET_CAPABILITY_SCHEMA = "hasna.instructions.asset-capability/v1";
 var ASSET_BUNDLE_SCHEMA = "hasna.instructions.asset-bundle/v1";
@@ -9593,16 +9591,51 @@ function indexHeader(tool, profile) {
   ].join(`
 `);
 }
-function buildNativeImportFiles(targetHome, adapter, profile, sources) {
+var CLAUDE_PATHS_RULES_VERSION_RANGE = ">=2.1.84";
+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 = [
@@ -9790,10 +9823,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":
@@ -10040,7 +10073,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,
@@ -10665,7 +10698,12 @@ function capability(provider, providerVersionRange, selectedRepresentation, load
   });
 }
 var 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" }),
@@ -11011,7 +11049,6 @@ function planProfileSessionRender(input) {
   });
   const {
     profile_id: _profileId,
-    provider_version: _providerVersion,
     configs: _configs,
     bindings: _bindings,
     asset_configs: _assetConfigs,
@@ -12210,7 +12247,7 @@ async function applyPreparedConfig(config, opts) {
       changed: outputResults.some((output) => output.changed)
     };
   }
-  if (!opts.dryRun) {
+  if (!opts.dryRun && result.changed) {
     await store.updateConfig(config.id, { synced_at: new Date().toISOString() });
   }
   return result;
@@ -12916,7 +12953,7 @@ async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
   let unredactedSecretFindings = 0;
   let knownTargets = 0;
   for (const config of fileConfigs) {
-    unredactedSecretFindings += scanSecrets(config.content, config.format).length;
+    unredactedSecretFindings += scanSecrets(config.content, redactFormatForTarget(config.target_path ?? "", config.format)).length;
     if (isRetiredOrUnsupportedConfigAgent(config.agent))
       continue;
     if (!config.target_path)
@@ -12928,7 +12965,7 @@ async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
       continue;
     }
     const disk = readFileSync9(targetPath, "utf-8");
-    const { content: redactedDisk } = redactContent(disk, config.format);
+    const { content: redactedDisk } = redactContent(disk, redactFormatForTarget(config.target_path, config.format));
     if (redactedDisk !== config.content) {
       driftedTargets += 1;
     }
@@ -13751,21 +13788,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);
@@ -14332,14 +14372,15 @@ async function syncFromDir(dir, opts = {}) {
         continue;
       }
       const targetPath = file.replace(home, "~");
+      const redacted = redactContent(content, redactFormatForTarget(targetPath, detectFormat(file)));
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative6(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
+          await store.createConfig({ name: relative6(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content: redacted.content });
         result.added++;
-      } else if (existing.content !== content) {
+      } else if (existing.content !== redacted.content) {
         if (!opts.dryRun)
-          await store.updateConfig(existing.id, { content });
+          await store.updateConfig(existing.id, { content: redacted.content });
         result.updated++;
       } else {
         result.unchanged++;
@@ -14647,7 +14688,7 @@ async function syncKnown(opts = {}) {
         continue;
       }
       const fmt = known.format ?? detectFormat(abs);
-      const redacted = redactContent(rawContent, fmt);
+      const redacted = redactContent(rawContent, redactFormatForTarget(abs, fmt));
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
       const isTemplate2 = redacted.isTemplate || machineAware.changed;
@@ -15395,163 +15436,163 @@ function toPosix(path) {
   return path.split("\\").join("/");
 }
 export {
-  AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY,
-  AGENT_OPERATING_RULES_SENTINEL_PATTERN,
-  ASSET_BUNDLE_SCHEMA,
-  ASSET_CAPABILITY_DESCRIPTORS,
-  ASSET_CAPABILITY_SCHEMA,
-  ASSET_DESTINATION_STRATEGIES,
-  ASSET_KINDS,
-  ASSET_PLAN_SCHEMA,
-  ASSET_ROLLBACK_POLICIES,
-  ASSET_SCOPES,
-  ASSET_UNINSTALL_POLICIES,
-  AssetPlanValidationError,
-  CODEWITH_NATIVE_IMPORTS_ENV,
-  CODEWITH_SHARED_TODOS_STORAGE_POLICY_REFERENCE,
-  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_CONTENT,
-  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_SLUG,
-  CONFIG_AGENTS,
-  CONFIG_CATEGORIES,
-  CONFIG_FORMATS,
-  CONFIG_KINDS,
-  CONFIG_TRANSFORMS,
-  CloudConfigStore,
-  CloudHttpError,
-  ConfigApplyError,
-  ConfigNotFoundError,
-  DANGEROUS_OPERATION_GUARD_STANDARD_CONTENT,
-  DANGEROUS_OPERATION_GUARD_STANDARD_SLUG,
-  GLOBAL_AGENT_RULES_STANDARD_CONTENT,
-  GLOBAL_AGENT_RULES_STANDARD_SLUG,
-  INBOX_CONVERSATIONS_MINIMUM_VERSION,
-  INSTRUCTION_ACTIVATION_MODES,
-  INSTRUCTION_FALLBACKS,
-  INSTRUCTION_GRAPH_PLAN_SCHEMA,
-  InstructionGraphValidationError,
-  KNOWN_CONFIGS,
-  LEGACY_CONFIGS_COMPAT_VERSION,
-  LEGACY_CONFIGS_EXECUTABLE,
-  LEGACY_CONFIGS_PACKAGE,
-  LocalConfigStore,
-  PG_MIGRATIONS,
-  PLATFORM_PROFILE_PRESETS,
-  PROFILE_ASSET_BINDING_SCHEMA,
-  PROFILE_CONFIG_BINDING_SCHEMA,
-  PROJECT_CONFIG_FILES,
-  PROJECT_CONTEXT_CACHE_PATH,
-  PROJECT_CONTEXT_FRAGMENT_PATH,
-  PROJECT_CONTEXT_LOCK_PATH,
-  PROJECT_CONTEXT_MANAGED_COMMENT,
-  PROJECT_CONTEXT_MANIFEST_PATH,
-  PROJECT_CONTEXT_MAX_COMMANDS,
-  PROJECT_CONTEXT_MAX_INPUT_BYTES,
-  PROJECT_CONTEXT_MAX_RENDERED_BYTES,
-  PROJECT_CONTEXT_SCHEMA,
-  PROJECT_DASHBOARD_PROFILE_VARIABLES,
-  PROJECT_DASHBOARD_STANDARD_CONTENT,
-  PROJECT_DASHBOARD_STANDARD_SLUG,
-  PROVIDER_CAPABILITIES,
-  PROVIDER_CAPABILITY_DESCRIPTORS,
-  PROVIDER_CAPABILITY_SCHEMA,
-  ProfileNotFoundError,
-  ProjectContextError,
-  RAW_STORE_ROOT_ENV,
-  SESSION_INSTRUCTION_LAYERS,
-  SESSION_LAYER_RANK,
-  SESSION_RENDER_MANAGED_MARKER,
-  SESSION_RENDER_SCHEMA,
-  SESSION_RENDER_TOOLS,
-  SESSION_TOOL_ADAPTERS,
-  SessionApplyError,
-  TemplateRenderError,
-  applyConfig,
-  applyConfigs,
-  applyConfigsWithReport,
-  applyProjectContext,
-  applySessionRender,
-  applyTransform,
-  assetBundleFromConfig,
-  boundedReadPage,
-  buildCodexAgentsMd,
-  buildCursorMdc,
-  buildOpenCodeAgentsMd,
-  checkSessionRenderDrift,
-  cleanSessionPathInput,
-  compareAgentOperatingRulesVersions,
-  compileAssetPlan,
-  compileInstructionGraph,
-  computeProjectContextSourceHash,
-  configAssetDigest,
-  configAssetLocator,
-  currentArch2 as currentArch,
-  currentHostname2 as currentHostname,
-  currentOs,
-  detectAgent,
-  detectCategory,
-  detectFormat,
-  detectMachineContext,
-  diffConfig,
-  ensureCodewithSharedTodosStorageStandardConfig,
-  ensureDangerousOperationGuardStandardConfig,
-  ensureGlobalAgentRulesStandardConfig,
-  ensurePlatformProfiles,
-  ensureProjectDashboardStandardConfig,
-  expandPath,
-  exportConfigs,
-  extractTemplateVars,
-  getConfigsStatus,
-  getRawStoreRoot,
-  hasSecrets,
-  importConfigs,
-  inspectManagedSkillRuntimes,
-  isApiTransport,
-  isTemplate,
-  legacyProfileConfigBinding,
-  machineContextToVariables,
-  normalizeBoundedReadOptions,
-  normalizeOsFamily,
-  normalizeProfileAssetBinding,
-  normalizeProfileConfigBinding,
-  now,
-  parseAgentOperatingRulesVersion,
-  parseProjectContextBundle,
-  parseTemplateVars,
-  planProfileSessionRender,
-  planProjectContext,
-  planSessionRender,
-  previewConfigs,
-  providerVersionSatisfies,
-  reconcileManagedSkillRuntimes,
-  redactContent,
-  renderMachineAwareContent,
-  renderMachineAwareContentPreview,
-  renderTemplate,
-  renderTemplatePreview,
-  resolveAgentOperatingRulesPayload,
-  resolveAssetDestination,
-  resolveCloudConfig,
-  resolveConfigStore,
-  resolveProfileVariables,
-  resolveSessionPath,
-  resolveSessionTargetOwnership,
-  restoreSessionRenderSnapshot,
-  scanPackageManagerSecrets,
-  scanSecrets,
-  selectAssetCapability,
-  selectProfileConfigsForSessionRender,
-  selectProviderCapability,
-  slugify,
-  sourceFromConfig,
-  sourceFromFilePath,
-  sourcesFromIdentityExport,
-  stripClaudeOnlySections,
-  syncFromDir,
-  syncKnown,
-  syncProject,
-  syncToDir,
-  syncToDisk,
-  templateizeMachineContent,
+  uuid,
   transformSkillContent,
-  uuid
+  templateizeMachineContent,
+  syncToDisk,
+  syncToDir,
+  syncProject,
+  syncKnown,
+  syncFromDir,
+  stripClaudeOnlySections,
+  sourcesFromIdentityExport,
+  sourceFromFilePath,
+  sourceFromConfig,
+  slugify,
+  selectProviderCapability,
+  selectProfileConfigsForSessionRender,
+  selectAssetCapability,
+  scanSecrets,
+  scanPackageManagerSecrets,
+  restoreSessionRenderSnapshot,
+  resolveSessionTargetOwnership,
+  resolveSessionPath,
+  resolveProfileVariables,
+  resolveConfigStore,
+  resolveCloudConfig,
+  resolveAssetDestination,
+  resolveAgentOperatingRulesPayload,
+  renderTemplatePreview,
+  renderTemplate,
+  renderMachineAwareContentPreview,
+  renderMachineAwareContent,
+  redactContent,
+  reconcileManagedSkillRuntimes,
+  providerVersionSatisfies,
+  previewConfigs,
+  planSessionRender,
+  planProjectContext,
+  planProfileSessionRender,
+  parseTemplateVars,
+  parseProjectContextBundle,
+  parseAgentOperatingRulesVersion,
+  now,
+  normalizeProfileConfigBinding,
+  normalizeProfileAssetBinding,
+  normalizeOsFamily,
+  normalizeBoundedReadOptions,
+  machineContextToVariables,
+  legacyProfileConfigBinding,
+  isTemplate,
+  isApiTransport,
+  inspectManagedSkillRuntimes,
+  importConfigs,
+  hasSecrets,
+  getRawStoreRoot,
+  getConfigsStatus,
+  extractTemplateVars,
+  exportConfigs,
+  expandPath,
+  ensureProjectDashboardStandardConfig,
+  ensurePlatformProfiles,
+  ensureGlobalAgentRulesStandardConfig,
+  ensureDangerousOperationGuardStandardConfig,
+  ensureCodewithSharedTodosStorageStandardConfig,
+  diffConfig,
+  detectMachineContext,
+  detectFormat,
+  detectCategory,
+  detectAgent,
+  currentOs,
+  currentHostname2 as currentHostname,
+  currentArch2 as currentArch,
+  configAssetLocator,
+  configAssetDigest,
+  computeProjectContextSourceHash,
+  compileInstructionGraph,
+  compileAssetPlan,
+  compareAgentOperatingRulesVersions,
+  cleanSessionPathInput,
+  checkSessionRenderDrift,
+  buildOpenCodeAgentsMd,
+  buildCursorMdc,
+  buildCodexAgentsMd,
+  boundedReadPage,
+  assetBundleFromConfig,
+  applyTransform,
+  applySessionRender,
+  applyProjectContext,
+  applyConfigsWithReport,
+  applyConfigs,
+  applyConfig,
+  TemplateRenderError,
+  SessionApplyError,
+  SESSION_TOOL_ADAPTERS,
+  SESSION_RENDER_TOOLS,
+  SESSION_RENDER_SCHEMA,
+  SESSION_RENDER_MANAGED_MARKER,
+  SESSION_LAYER_RANK,
+  SESSION_INSTRUCTION_LAYERS,
+  RAW_STORE_ROOT_ENV,
+  ProjectContextError,
+  ProfileNotFoundError,
+  PROVIDER_CAPABILITY_SCHEMA,
+  PROVIDER_CAPABILITY_DESCRIPTORS,
+  PROVIDER_CAPABILITIES,
+  PROJECT_DASHBOARD_STANDARD_SLUG,
+  PROJECT_DASHBOARD_STANDARD_CONTENT,
+  PROJECT_DASHBOARD_PROFILE_VARIABLES,
+  PROJECT_CONTEXT_SCHEMA,
+  PROJECT_CONTEXT_MAX_RENDERED_BYTES,
+  PROJECT_CONTEXT_MAX_INPUT_BYTES,
+  PROJECT_CONTEXT_MAX_COMMANDS,
+  PROJECT_CONTEXT_MANIFEST_PATH,
+  PROJECT_CONTEXT_MANAGED_COMMENT,
+  PROJECT_CONTEXT_LOCK_PATH,
+  PROJECT_CONTEXT_FRAGMENT_PATH,
+  PROJECT_CONTEXT_CACHE_PATH,
+  PROJECT_CONFIG_FILES,
+  PROFILE_CONFIG_BINDING_SCHEMA,
+  PROFILE_ASSET_BINDING_SCHEMA,
+  PLATFORM_PROFILE_PRESETS,
+  PG_MIGRATIONS,
+  LocalConfigStore,
+  LEGACY_CONFIGS_PACKAGE,
+  LEGACY_CONFIGS_EXECUTABLE,
+  LEGACY_CONFIGS_COMPAT_VERSION,
+  KNOWN_CONFIGS,
+  InstructionGraphValidationError,
+  INSTRUCTION_GRAPH_PLAN_SCHEMA,
+  INSTRUCTION_FALLBACKS,
+  INSTRUCTION_ACTIVATION_MODES,
+  INBOX_CONVERSATIONS_MINIMUM_VERSION,
+  GLOBAL_AGENT_RULES_STANDARD_SLUG,
+  GLOBAL_AGENT_RULES_STANDARD_CONTENT,
+  DANGEROUS_OPERATION_GUARD_STANDARD_SLUG,
+  DANGEROUS_OPERATION_GUARD_STANDARD_CONTENT,
+  ConfigNotFoundError,
+  ConfigApplyError,
+  CloudHttpError,
+  CloudConfigStore,
+  CONFIG_TRANSFORMS,
+  CONFIG_KINDS,
+  CONFIG_FORMATS,
+  CONFIG_CATEGORIES,
+  CONFIG_AGENTS,
+  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_SLUG,
+  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_CONTENT,
+  CODEWITH_SHARED_TODOS_STORAGE_POLICY_REFERENCE,
+  CODEWITH_NATIVE_IMPORTS_ENV,
+  AssetPlanValidationError,
+  ASSET_UNINSTALL_POLICIES,
+  ASSET_SCOPES,
+  ASSET_ROLLBACK_POLICIES,
+  ASSET_PLAN_SCHEMA,
+  ASSET_KINDS,
+  ASSET_DESTINATION_STRATEGIES,
+  ASSET_CAPABILITY_SCHEMA,
+  ASSET_CAPABILITY_DESCRIPTORS,
+  ASSET_BUNDLE_SCHEMA,
+  AGENT_OPERATING_RULES_SENTINEL_PATTERN,
+  AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY
 };