@hasna/instructions 0.7.1 → 0.7.2

package/dist/index.js

@@ -16,7 +16,12 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // src/types/index.ts
-var CONFIG_KINDS, CONFIG_CATEGORIES, CONFIG_AGENTS, CONFIG_TRANSFORMS, CONFIG_FORMATS, PROFILE_CONFIG_BINDING_SCHEMA = "hasna.instructions.profile-config-binding/v1", INSTRUCTION_ACTIVATION_MODES, INSTRUCTION_FALLBACKS, PROFILE_ASSET_BINDING_SCHEMA = "hasna.instructions.profile-asset-binding/v1", ASSET_KINDS, ASSET_DESTINATION_STRATEGIES, ASSET_SCOPES, ASSET_UNINSTALL_POLICIES, ASSET_ROLLBACK_POLICIES, INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA = "hasna.instructions.domain-archive/v2", ConfigNotFoundError, ProfileNotFoundError, ConfigApplyError, TemplateRenderError;
+function validateExpectedConfigVersion(value) {
+  if (value !== undefined && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1)) {
+    throw new InvalidExpectedVersionError;
+  }
+}
+var CONFIG_KINDS, CONFIG_CATEGORIES, CONFIG_AGENTS, CONFIG_TRANSFORMS, CONFIG_FORMATS, PROFILE_CONFIG_BINDING_SCHEMA = "hasna.instructions.profile-config-binding/v1", INSTRUCTION_ACTIVATION_MODES, INSTRUCTION_FALLBACKS, PROFILE_ASSET_BINDING_SCHEMA = "hasna.instructions.profile-asset-binding/v1", ASSET_KINDS, ASSET_DESTINATION_STRATEGIES, ASSET_SCOPES, ASSET_UNINSTALL_POLICIES, ASSET_ROLLBACK_POLICIES, INSTRUCTIONS_DOMAIN_ARCHIVE_SCHEMA = "hasna.instructions.domain-archive/v2", InvalidExpectedVersionError, ConfigVersionConflictError, ConfigNotFoundError, ProfileNotFoundError, ConfigApplyError, TemplateRenderError;
 var init_types = __esm(() => {
   CONFIG_KINDS = ["file", "reference"];
   CONFIG_CATEGORIES = [
@@ -33,6 +38,7 @@ var init_types = __esm(() => {
     "claude",
     "codex",
     "opencode",
+    "sumi",
     "cursor",
     "codewith",
     "aicopilot",
@@ -53,6 +59,7 @@ var init_types = __esm(() => {
     "claude-passthrough",
     "codex-flat",
     "opencode-flat",
+    "sumi-flat",
     "cursor-mdc",
     "skill-neutral"
   ];
@@ -71,6 +78,25 @@ var init_types = __esm(() => {
   ASSET_SCOPES = ["global", "project", "session"];
   ASSET_UNINSTALL_POLICIES = ["remove-managed", "retain"];
   ASSET_ROLLBACK_POLICIES = ["snapshot", "installer-receipt", "none"];
+  InvalidExpectedVersionError = class InvalidExpectedVersionError extends Error {
+    code = "INVALID_EXPECTED_VERSION";
+    constructor() {
+      super("expected_version must be a positive safe integer");
+      this.name = "InvalidExpectedVersionError";
+    }
+  };
+  ConfigVersionConflictError = class ConfigVersionConflictError extends Error {
+    config_id;
+    expected_version;
+    code = "CONFIG_VERSION_CONFLICT";
+    status = 409;
+    constructor(config_id, expected_version) {
+      super(`Config version conflict: ${config_id} no longer has expected version ${expected_version}`);
+      this.config_id = config_id;
+      this.expected_version = expected_version;
+      this.name = "ConfigVersionConflictError";
+    }
+  };
   ConfigNotFoundError = class ConfigNotFoundError extends Error {
     constructor(id) {
       super(`Config not found: ${id}`);
@@ -143,6 +169,31 @@ function boundedReadPage(items, total, options = {}) {
 }
 var init_bounded_read = () => {};
 
+// src/lib/instruction-source-policy.ts
+function isRetiredInstructionSource(config) {
+  return config.tags.some((tag) => tag === "retired-global-source" || tag === "retired-instruction-source");
+}
+function instructionSourceRejection(config) {
+  if (isRetiredInstructionSource(config) || config.tags.includes("config-only")) {
+    return "source is retired or explicitly configuration-only";
+  }
+  if (config.category !== "rules")
+    return `category ${config.category} is not an instruction source; classify reviewed prose as rules`;
+  if (config.format !== "markdown" && config.format !== "text")
+    return `format ${config.format} is not instruction prose`;
+  if (config.is_template)
+    return "unresolved templates must be rendered and reviewed before prompt injection";
+  if (!config.content.trim())
+    return "instruction source is empty";
+  if (config.content.includes("\x00"))
+    return "instruction source contains binary content";
+  const target = config.target_path?.split(/[\\/]/).pop() ?? "";
+  if (/\.(?:json|toml|yaml|yml|ini|sh|bash|zsh|fish|js|ts|py|rules)$/i.test(target)) {
+    return "target is an executable, provider policy, or settings file rather than a prompt";
+  }
+  return null;
+}
+
 // src/lib/global-agent-rules-standard.ts
 import { createHash } from "crypto";
 function parseAgentOperatingRulesVersion(content) {
@@ -246,9 +297,13 @@ async function ensureGlobalAgentRulesStandardConfig(store = resolveConfigStore()
   let existing;
   try {
     existing = await store.getConfig(GLOBAL_AGENT_RULES_STANDARD_SLUG);
-  } catch {
+  } catch (error) {
+    if (!(error instanceof ConfigNotFoundError))
+      throw error;
     return await store.createConfig(standardConfigInput(resolveAgentOperatingRulesPayload(null)));
   }
+  if (isRetiredInstructionSource(existing))
+    return existing;
   const payload = resolveAgentOperatingRulesPayload(existing.content);
   const input = standardConfigInput(payload);
   if (existing.content !== input.content || existing.description !== input.description || existing.category !== input.category || existing.agent !== input.agent || existing.format !== input.format || existing.kind !== input.kind || JSON.stringify(existing.tags) !== JSON.stringify(input.tags)) {
@@ -258,6 +313,7 @@ async function ensureGlobalAgentRulesStandardConfig(store = resolveConfigStore()
 }
 var GLOBAL_AGENT_RULES_STANDARD_SLUG = "global-agent-rules-standard", AGENT_OPERATING_RULES_SOURCE_SET_ID = "hasna-global-agent-rules-standard", AGENT_OPERATING_RULES_SOURCE_ID = "hasna-agent-operating-rules", AGENT_OPERATING_RULES_ROLE = "agent-operating-rules", AGENT_OPERATING_RULES_VERSION = "1.1.26", AGENT_OPERATING_RULES_SOURCE_SET_VERSION = "2026-08-11", AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY = "hasna:agent-operating-rules", AGENT_OPERATING_RULES_SENTINEL_PATTERN, AGENT_OPERATING_RULES_HEADING_PATTERN, AGENT_OPERATING_RULES_PAYLOAD_SHA256 = "486844a3d869e3dabc2f33fd66479d4e2fb0a0d1864a3d8a3dd05669eb3f1b77", AGENT_OPERATING_RULES_UPSTREAM_FILE_SHA256 = "b8e89cdb49e207e5b497ac51384d67022b94fe5645cc9273db60384eb2c2fb32", SCOPED_OPERATIONAL_CONTROL_POLICY_REFERENCE = "hasna-agent-operating-rules/scoped-operational-control/v1", AGENT_OPERATING_RULES_UPSTREAM, SCOPED_OPERATIONAL_CONTROL_POLICY, AGENT_OPERATING_RULES_PROVENANCE, AGENT_OPERATING_RULES_METADATA, GLOBAL_AGENT_RULES_STANDARD_CONTENT;
 var init_global_agent_rules_standard = __esm(() => {
+  init_types();
   init_config_store();
   AGENT_OPERATING_RULES_SENTINEL_PATTERN = /<!--\s*hasna:agent-operating-rules\s+v=([0-9]+\.[0-9]+\.[0-9]+)\s*-->/i;
   AGENT_OPERATING_RULES_HEADING_PATTERN = /^#\s*Hasna Agent Operating Rules\s+\u2014\s+v[0-9]+\.[0-9]+\.[0-9]+\s+\(([0-9]{4}-[0-9]{2}-[0-9]{2})\)/;
@@ -384,21 +440,23 @@ async function ensureCodewithSharedTodosStorageStandardConfig(store = resolveCon
   let config;
   try {
     const existing = await store.getConfig(CODEWITH_SHARED_TODOS_STORAGE_STANDARD_SLUG);
+    if (isRetiredInstructionSource(existing))
+      return existing;
     if (existing.content !== input.content || existing.description !== input.description || existing.category !== input.category || existing.agent !== input.agent || existing.format !== input.format || existing.kind !== input.kind || JSON.stringify(existing.tags) !== JSON.stringify(input.tags)) {
       config = await store.updateConfig(existing.id, input);
     } else {
       config = existing;
     }
-  } catch {
+  } catch (error) {
+    if (!(error instanceof ConfigNotFoundError))
+      throw error;
     config = await store.createConfig(input);
   }
-  for (const profile of await store.listProfiles()) {
-    await store.addConfigToProfile(profile.id, config.id);
-  }
   return config;
 }
 var CODEWITH_SHARED_TODOS_STORAGE_STANDARD_SLUG = "codewith-shared-todos-storage-standard", CODEWITH_SHARED_TODOS_STORAGE_POLICY_REFERENCE = "codewith/shared-todos-storage/v1", CODEWITH_SHARED_TODOS_STORAGE_STANDARD_CONTENT;
 var init_codewith_shared_todos_storage_standard = __esm(() => {
+  init_types();
   init_config_store();
   CODEWITH_SHARED_TODOS_STORAGE_STANDARD_CONTENT = `# Codewith Shared Todos Storage Standard
 
@@ -7292,7 +7350,7 @@ function sha2562(content) {
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
-var PROJECT_CONTEXT_SCHEMA = "hasna.projects.project_context_bundle.v1", PROJECT_CONTEXT_SCHEMA_V2 = "hasna.projects.project_context_bundle.v2", PROJECT_CONTEXT_SUPPORTED_SCHEMAS, projectContextSchema, PROJECT_CONTEXT_MAX_INPUT_BYTES, PROJECT_CONTEXT_MAX_RENDERED_BYTES, PROJECT_CONTEXT_MAX_APPROX_TOKENS = 1000, PROJECT_CONTEXT_MAX_COMMANDS = 6, PROJECT_CONTEXT_MAX_WARNINGS = 3, PROJECT_CONTEXT_FRAGMENT_PATH = ".hasna/instructions/project-context.md", PROJECT_CONTEXT_MANIFEST_PATH = ".hasna/projects/project-context-manifest.json", PROJECT_CONTEXT_CACHE_PATH = ".hasna/projects/project-context-cache.json", PROJECT_CONTEXT_LOCK_PATH = ".hasna/projects/project-context.lock", PROJECT_CONTEXT_SNAPSHOT_DIR = ".hasna/projects/project-context-snapshots", PROJECT_CONTEXT_CACHE_SCHEMA = "hasna.instructions.project-context-cache/v1", PROJECT_CONTEXT_MANAGED_COMMENT = "Managed by @hasna/configs project context", SESSION_COMPATIBILITY_MANIFEST_MAX_BYTES, FOREIGN_INPUT_MAX_BYTES, SESSION_MANAGED_OUTPUT_MAX_BYTES, SESSION_MANAGED_OUTPUT_PATHS, SESSION_MANAGED_OUTPUT_WARN_BYTES, PROJECT_CONTEXT_LOCK_STALE_MS, LEGACY_CONFIGS_PACKAGE = "@hasna/configs", LEGACY_CONFIGS_COMPAT_VERSION = "0.2.45", LEGACY_CONFIGS_EXECUTABLE = "configs", PROJECT_KINDS, PROJECT_STATUSES, LINK_STATES, RESOLUTION_SOURCES, safeId, nullableId, producerSlug, producerName, safeOptionalDisplay, isoTimestamp, revisionSchema, hashSchema, absolutePath, commandArg, financeText, financeLegalEntity, financeProjectMetadataSchema, commandSchema, projectContextBundleSchema, storedManifestProjectContextSchema, storedManifestFileSchema, storedManifestObservationSchema, projectContextMetadataSnapshotSchema, projectContextCacheSchema, ProjectContextError, ProjectContextHashRace, anchoredFsOps, atomicExchange, atomicExchangeLibraries;
+var PROJECT_CONTEXT_SCHEMA = "hasna.projects.project_context_bundle.v1", PROJECT_CONTEXT_SCHEMA_V2 = "hasna.projects.project_context_bundle.v2", PROJECT_CONTEXT_SUPPORTED_SCHEMAS, projectContextSchema, PROJECT_CONTEXT_MAX_INPUT_BYTES, PROJECT_CONTEXT_MAX_RENDERED_BYTES, PROJECT_CONTEXT_MAX_APPROX_TOKENS = 1000, PROJECT_CONTEXT_MAX_COMMANDS = 6, PROJECT_CONTEXT_MAX_WARNINGS = 3, PROJECT_CONTEXT_FRAGMENT_PATH = ".hasna/instructions/project-context.md", PROJECT_CONTEXT_MANIFEST_PATH = ".hasna/projects/project-context-manifest.json", PROJECT_CONTEXT_CACHE_PATH = ".hasna/projects/project-context-cache.json", PROJECT_CONTEXT_LOCK_PATH = ".hasna/projects/project-context.lock", PROJECT_CONTEXT_SNAPSHOT_DIR = ".hasna/projects/project-context-snapshots", PROJECT_CONTEXT_CACHE_SCHEMA = "hasna.instructions.project-context-cache/v1", PROJECT_CONTEXT_MANAGED_COMMENT = "Managed by @hasna/configs project context", SESSION_COMPATIBILITY_MANIFEST_MAX_BYTES, FOREIGN_INPUT_MAX_BYTES, SESSION_MANAGED_OUTPUT_MAX_BYTES, SESSION_MANAGED_INPUT_MAX_BYTES, SESSION_MANAGED_OUTPUT_PATHS, SESSION_MANAGED_OUTPUT_WARN_BYTES, PROJECT_CONTEXT_LOCK_STALE_MS, LEGACY_CONFIGS_PACKAGE = "@hasna/configs", LEGACY_CONFIGS_COMPAT_VERSION = "0.2.45", LEGACY_CONFIGS_EXECUTABLE = "configs", PROJECT_KINDS, PROJECT_STATUSES, LINK_STATES, RESOLUTION_SOURCES, safeId, nullableId, producerSlug, producerName, safeOptionalDisplay, isoTimestamp, revisionSchema, hashSchema, absolutePath, commandArg, financeText, financeLegalEntity, financeProjectMetadataSchema, commandSchema, projectContextBundleSchema, storedManifestProjectContextSchema, storedManifestFileSchema, storedManifestObservationSchema, projectContextMetadataSnapshotSchema, projectContextCacheSchema, ProjectContextError, ProjectContextHashRace, anchoredFsOps, atomicExchange, atomicExchangeLibraries;
 var init_project_context = __esm(() => {
   init_zod();
   init_redact();
@@ -7305,6 +7363,7 @@ var init_project_context = __esm(() => {
   SESSION_COMPATIBILITY_MANIFEST_MAX_BYTES = 8 * 1024 * 1024;
   FOREIGN_INPUT_MAX_BYTES = 256 * 1024;
   SESSION_MANAGED_OUTPUT_MAX_BYTES = SESSION_COMPATIBILITY_MANIFEST_MAX_BYTES;
+  SESSION_MANAGED_INPUT_MAX_BYTES = SESSION_MANAGED_OUTPUT_MAX_BYTES;
   SESSION_MANAGED_OUTPUT_PATHS = [
     ".hasna/session-render-manifest.json",
     ".codewith/.hasna/session-render-manifest.json",
@@ -7604,6 +7663,9 @@ function buildCodexAgentsMd(source, context = {}) {
 function buildOpenCodeAgentsMd(source, context = {}) {
   return flattenWithRules(source, context);
 }
+function buildSumiAgentsMd(source, context = {}) {
+  return flattenWithRules(source, context);
+}
 function buildCursorMdc(source) {
   const stem = source.target_path ? basename2(source.target_path, extname(source.target_path)) : source.slug;
   const description = source.name || stem;
@@ -7632,6 +7694,8 @@ function applyTransform(source, output, context = {}) {
       return buildCodexAgentsMd(source, context);
     case "opencode-flat":
       return buildOpenCodeAgentsMd(source, context);
+    case "sumi-flat":
+      return buildSumiAgentsMd(source, context);
     case "cursor-mdc":
       return buildCursorMdc(source);
     case "skill-neutral":
@@ -8050,6 +8114,7 @@ var init_asset_plan = __esm(() => {
     codex: "cli",
     cursor: "ide",
     opencode: "cli",
+    sumi: "cli",
     codewith: "cli",
     qwen: "cli",
     aicopilot: "cli",
@@ -8698,9 +8763,19 @@ function skippedSource(source, reason) {
   };
 }
 function normalizeSources(sources, tool, allowEmptySources) {
-  const normalized = sources.map((source, index) => {
+  const providerSkipped = [];
+  const normalized = sources.flatMap((source, index) => {
     if (!source.id.trim())
       throw new Error("Session instruction source id is required.");
+    if (source.targetProviders?.length && !providerTargetsTool(source.targetProviders, tool)) {
+      providerSkipped.push({
+        id: source.id,
+        label: source.label ?? source.id,
+        targetProviders: source.targetProviders,
+        reason: "instruction source targets a different provider"
+      });
+      return [];
+    }
     const floored = applyAgentOperatingRulesFloor(source, source.content ?? "");
     const content = filterProviderOnlyBlocks(floored.content, tool);
     const normalized2 = {
@@ -8719,7 +8794,7 @@ function normalizeSources(sources, tool, allowEmptySources) {
     if (!allowEmptySources && !normalized2.content.trim() && normalized2.resolvedRules.length === 0 && !hasPathReferences) {
       throw new Error(`Session instruction source "${source.id}" is empty. Pass --allow-empty-sources only for explicit empty renders.`);
     }
-    return normalized2;
+    return [normalized2];
   });
   const originalOrder = [...normalized].sort(compareSessionInstructionSources);
   const deduplicated = deduplicateSemanticPolicySources(normalized);
@@ -8727,7 +8802,7 @@ function normalizeSources(sources, tool, allowEmptySources) {
   validateTargetedReplacementSources(originalOrder, ordered, deduplicated.skipped, tool);
   rejectDuplicateSourceSlugs(ordered);
   rejectDuplicateRulePaths(ordered);
-  return { sources: ordered, skipped: deduplicated.skipped };
+  return { sources: ordered, skipped: [...providerSkipped, ...deduplicated.skipped] };
 }
 function compareSessionInstructionSources(a, b) {
   return SESSION_LAYER_RANK[a.resolvedLayer] - SESSION_LAYER_RANK[b.resolvedLayer] || a.resolvedOrder - b.resolvedOrder || a.id.localeCompare(b.id);
@@ -9332,6 +9407,11 @@ function isNativeProfileSessionTarget(input) {
   return (input.tool === "grok" || input.tool === "devin") && Boolean(input.targetHome?.trim()) && !input.projectRoot;
 }
 function adapterFor(input) {
+  if (input.tool === "sumi" && input.projectRoot) {
+    if (input.providerSurface)
+      throw new Error(`Provider surface ${input.providerSurface} is not valid for Sumi.`);
+    return Object.freeze({ ...SESSION_TOOL_ADAPTERS.sumi, projectScoped: true, envVar: undefined });
+  }
   if (input.tool === "opencode" && input.providerSurface) {
     if (input.providerSurface !== "opencode-config-instructions" && input.providerSurface !== "opencode-agents-md") {
       throw new Error(`Provider surface ${input.providerSurface} is not valid for OpenCode.`);
@@ -9373,7 +9453,7 @@ function adapterFor(input) {
   }
   if (input.tool !== "codewith")
     return SESSION_TOOL_ADAPTERS[input.tool];
-  const gatedNativeImports = input.codewithNativeImports === true || process.env[CODEWITH_NATIVE_IMPORTS_ENV] === "1" || process.env[CODEWITH_NATIVE_IMPORTS_ENV] === "true";
+  const gatedNativeImports = input.codewithNativeImports ?? (process.env[CODEWITH_NATIVE_IMPORTS_ENV] === "1" || process.env[CODEWITH_NATIVE_IMPORTS_ENV] === "true");
   return gatedNativeImports ? CODEWITH_NATIVE_ADAPTER : CODEWITH_FLATTENED_ADAPTER;
 }
 function getHomeDir() {
@@ -9424,6 +9504,13 @@ function assertSafeTargetRoot(targetHome) {
   return normalized;
 }
 function resolveRenderTarget(input, adapter) {
+  if (input.tool === "sumi" && !input.projectRoot && !input.targetHome?.trim()) {
+    return {
+      targetHome: defaultTargetHome(input.tool, input.profile, input.sessionId),
+      targetKind: "blocked",
+      blockers: ["Sumi requires --target-home from `sumi debug paths config`, or --project-root for repository AGENTS.md."]
+    };
+  }
   if (adapter.projectScoped) {
     if (!input.projectRoot) {
       const label = input.tool === "cursor" ? "Cursor rules" : input.tool === "antigravity" ? "Antigravity rules" : `${adapter.description.split(".")[0]} files`;
@@ -9525,6 +9612,14 @@ function planSessionRender(input) {
   const normalized = normalizeSources(input.sources, input.tool, allowEmptySources);
   const composed = composeSources(normalized.sources, input.tool);
   const orderedSources = composed.sources;
+  if (input.tool === "sumi") {
+    for (const source of orderedSources) {
+      const activation = source.metadata?.["activation"];
+      if (source.globs?.length || source.resolvedRules.some((rule) => rule.globs?.length) || activation?.mode && activation.mode !== "always") {
+        throw new Error(`Sumi AGENTS.md cannot preserve conditional activation for source ${source.id}; compile a profile with an explicit supported fallback.`);
+      }
+    }
+  }
   const skippedSources = [
     ...input.skippedSources ?? [],
     ...normalized.skipped,
@@ -9568,6 +9663,7 @@ function planSessionRender(input) {
     adapterMode: adapter.mode,
     profile: input.profile,
     sessionId: input.sessionId ?? null,
+    ...input.refreshSelector ? { refreshSelector: input.refreshSelector } : {},
     targetHome,
     targetKind,
     targetOwner,
@@ -9741,8 +9837,9 @@ function selectProfileConfigsForSessionRender(configs, tool) {
         skippedSources.push(skippedProfileConfig(config, ["opencode"], "provider settings belong to OpenCode"));
       continue;
     }
-    if (config.category !== "rules") {
-      skippedSources.push(skippedProfileConfig(config, [], config.kind === "reference" ? "reference config is not a provider instruction source" : "profile config is handled by direct config preview/apply"));
+    const sourceRejection = instructionSourceRejection(config);
+    if (sourceRejection) {
+      skippedSources.push(skippedProfileConfig(config, [], sourceRejection));
       continue;
     }
     const output = config.outputs.find((candidate) => candidate.agent === tool);
@@ -9750,7 +9847,7 @@ function selectProfileConfigsForSessionRender(configs, tool) {
       skippedSources.push(skippedProfileConfig(config, [config.agent], "rule targets a different provider"));
       continue;
     }
-    const selectedContent = output ? applyTransform(config, output, { configs }) : config.content;
+    const selectedContent = output ? applyTransform(config, output, { configs: [config] }) : config.content;
     sources.push({
       config,
       source: sourceFromConfig({ ...config, content: selectedContent }, sources.length)
@@ -10159,6 +10256,7 @@ var init_session_render = __esm(() => {
     "codex",
     "cursor",
     "opencode",
+    "sumi",
     "codewith",
     "qwen",
     "aicopilot",
@@ -10247,6 +10345,15 @@ var init_session_render = __esm(() => {
       description: "OpenCode AGENTS.md plus opencode.json instructions pointing at managed fragments.",
       providerSurface: "legacy-dual"
     },
+    sumi: {
+      tool: "sumi",
+      mode: "flattened-markdown",
+      indexFile: "AGENTS.md",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
+      envVar: "SUMI_CONFIG_DIR",
+      nativeImports: false,
+      description: "Sumi native AGENTS.md in the explicit resolved config directory or project root."
+    },
     aicopilot: {
       tool: "aicopilot",
       mode: "flattened-markdown",
@@ -10535,12 +10642,22 @@ function compileInstructionGraph(input) {
     const selector = binding.providers?.find((entry) => entry.provider === input.context.provider || entry.provider === "global");
     if (binding.providers?.length && !selector)
       continue;
+    const output = config.outputs.find((entry) => entry.agent === input.context.provider);
+    if (!binding.providers?.length && config.agent !== "global" && config.agent !== input.context.provider && !output) {
+      diagnostics.push({ severity: "info", code: "SOURCE_PROVIDER_NOT_SELECTED", config_id: configId, message: `${config.slug} targets ${config.agent}, not ${input.context.provider}.` });
+      continue;
+    }
     if (selector?.version_range && !providerVersionSatisfies(input.context.provider_version, selector.version_range)) {
       diagnostics.push({ severity: binding.required ? "error" : "warning", code: "PROVIDER_SELECTOR_VERSION_MISMATCH", config_id: configId, message: `${config.slug} requires ${input.context.provider} ${selector.version_range}; current version is ${input.context.provider_version}.` });
       continue;
     }
     if (!activationMatches(binding.activation, config, input.context))
       continue;
+    const rejection = instructionSourceRejection(config);
+    if (rejection) {
+      diagnostics.push({ severity: !binding.required && binding.fallback === "omit" ? "warning" : "error", code: "SOURCE_NOT_INSTRUCTION", config_id: configId, message: `${config.slug}: ${rejection}.` });
+      continue;
+    }
     if (capability2.activation_modes.includes(binding.activation.mode)) {
       selected.add(configId);
       effective.set(configId, binding.activation);
@@ -10615,7 +10732,9 @@ function compileInstructionGraph(input) {
   assertExactOnce(units, artifacts);
   const sources = units.map((unit, index) => {
     const config = configs.get(unit.config_id);
-    return sourceForUnit(config, unit, index);
+    const output = config.outputs.find((entry) => entry.agent === input.context.provider);
+    const content = output ? applyTransform(config, output, { configs: [config] }) : config.content;
+    return sourceForUnit({ ...config, content }, unit, index);
   });
   const planWithoutHash = {
     schema: INSTRUCTION_GRAPH_PLAN_SCHEMA,
@@ -10843,6 +10962,7 @@ var init_instruction_graph = __esm(() => {
   init_types();
   init_session_render();
   init_asset_plan();
+  init_transforms();
   COMMON_FALLBACKS = ["fail", "flatten", "promote-always", "omit"];
   DEFAULT_PROVIDER_CAPABILITIES = Object.freeze({
     claude: capability("claude", ">=1.0.0", "native-import", "CLAUDE.md @ imports plus path-gated rules", {
@@ -10854,6 +10974,7 @@ var init_instruction_graph = __esm(() => {
     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" }),
+    sumi: capability("sumi", ">=0.2.22 <0.3.0", "flattened", "AGENTS.md"),
     codewith: capability("codewith", ">=0.1.0", "flattened", "CODEWITH.md"),
     qwen: capability("qwen", ">=0.1.0", "flattened", "QWEN.md"),
     aicopilot: capability("aicopilot", ">=0.1.0", "flattened", "AICOPILOT.md"),
@@ -13464,6 +13585,7 @@ function listConfigSummariesPage(filter = {}, options = {}, db) {
   })), total, normalized);
 }
 function updateConfig(idOrSlug, input, db) {
+  validateExpectedConfigVersion(input.expected_version);
   const d = db || getDatabase();
   const existing = getConfig(idOrSlug, d);
   const ts = now();
@@ -13519,7 +13641,15 @@ function updateConfig(idOrSlug, input, db) {
   }
   return d.transaction(() => {
     params.push(existing.id);
-    d.run(`UPDATE configs SET ${updates.join(", ")} WHERE id = ?`, params);
+    const condition = input.expected_version === undefined ? "" : " AND version = ?";
+    if (input.expected_version !== undefined)
+      params.push(input.expected_version);
+    const result = d.run(`UPDATE configs SET ${updates.join(", ")} WHERE id = ?${condition}`, params);
+    if (result.changes !== 1) {
+      if (input.expected_version !== undefined)
+        throw new ConfigVersionConflictError(existing.id, input.expected_version);
+      throw new ConfigNotFoundError(existing.id);
+    }
     const updated = getConfigById(existing.id, d);
     createSnapshot(updated.id, updated.content, updated.version, d);
     return updated;
@@ -14418,7 +14548,9 @@ class CloudConfigStore {
     return data.config;
   }
   async updateConfig(idOrSlug, input) {
-    const { data } = await this.request("PATCH", `/configs/${encodeURIComponent(idOrSlug)}`, input);
+    validateExpectedConfigVersion(input.expected_version);
+    const conditional = input.expected_version !== undefined;
+    const { data } = await this.request(conditional ? "POST" : "PATCH", `/configs/${encodeURIComponent(idOrSlug)}${conditional ? "/conditional-update" : ""}`, input);
     return data.config;
   }
   async deleteConfig(idOrSlug) {
@@ -14495,7 +14627,7 @@ class CloudConfigStore {
       throw new ProfileNotFoundError(idOrSlug);
     return parseBoundedOrLegacyPage(data.configs, data.profile.configs, normalized, "profile membership");
   }
-  async getProfileConfigBindings(idOrSlug) {
+  async getProfileConfigBindings(idOrSlug, options = {}) {
     let routeMissing = false;
     const bindings = await aggregateBoundedCollection("profile config bindings", async (cursor) => {
       const normalized = normalizeBoundedReadOptions({ limit: 100, cursor });
@@ -14508,6 +14640,8 @@ class CloudConfigStore {
     }, (binding) => `${binding.profile_id}\x00${binding.config_id}`);
     if (!routeMissing)
       return bindings;
+    if (options.requireExplicit)
+      throw new Error("HOSTED_BINDINGS_REQUIRED: profile config binding route is unavailable; refusing legacy activation fallback.");
     const profile = await this.getProfile(idOrSlug);
     const configs = await this.getProfileConfigs(idOrSlug);
     return configs.map((config, sort_order) => ({
@@ -14572,7 +14706,7 @@ class CloudConfigStore {
   async removeConfigFromProfile(profileIdOrSlug, configId) {
     await this.request("DELETE", `/profiles/${encodeURIComponent(profileIdOrSlug)}/configs/${encodeURIComponent(configId)}`, undefined, { allow404: true });
   }
-  async getProfileAssetBindings(profileIdOrSlug) {
+  async getProfileAssetBindings(profileIdOrSlug, options = {}) {
     let routeMissing = false;
     const assets = await aggregateBoundedCollection("profile asset bindings", async (cursor) => {
       const normalized = normalizeBoundedReadOptions({ limit: 100, cursor });
@@ -14585,6 +14719,8 @@ class CloudConfigStore {
     }, (asset) => `${asset.profile_id}\x00${asset.binding.assetKey}`);
     if (!routeMissing)
       return assets;
+    if (options.requireExplicit)
+      throw new Error("HOSTED_ASSETS_REQUIRED: profile asset binding route is unavailable; refusing an empty asset fallback.");
     await this.getProfile(profileIdOrSlug);
     return [];
   }
@@ -16334,7 +16470,6 @@ import {
   statSync as statSync5
 } from "fs";
 import { dirname as dirname10, isAbsolute as isAbsolute7, join as join17, parse as parse5, relative as relative6, resolve as resolve11 } from "path";
-
 class SessionApplyError extends Error {
   constructor(message) {
     super(message);
@@ -16356,14 +16491,20 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   const targetHome = assertSafeTargetHome(plan.targetHome);
   assertClaudeAuthorityStillClear(plan, targetHome, options.ownedClaudeAuthorities);
   const payloadFiles = [...plan.files, ...plan.assetFiles ?? []];
-  const files = [...payloadFiles, plan.manifestFile];
   const manifestPath = resolvePlannedFilePath(plan, plan.manifestFile, targetHome);
+  assertManifestPrecondition(manifestPath, targetHome, options.expectedManifestSha256);
   const previousManifest = readPreviousManifest(manifestPath);
   const previousHashes = previousManifest ? new Map(previousManifest.files.map((file) => [file.relativePath, file.sha256])) : new Map;
+  const adoptions = validateFileAdoptions(plan, targetHome, previousHashes, options);
+  const adoptedHashes = new Map(adoptions.map((entry) => [entry.relativePath, entry.preimageSha256]));
+  const reconciliations = validateFileReconciliations(plan, targetHome, previousManifest, options);
+  const reconciledHashes = new Map(reconciliations.map((entry) => [entry.relativePath, entry.preimageSha256]));
+  const manifestFile = manifestWithFileProvenance(plan, previousManifest, adoptions, reconciliations);
+  const files = [...payloadFiles, manifestFile];
   const currentRelativePaths = new Set(files.map((file) => file.relativePath));
   const drift = checkSessionRenderDrift(targetHome, manifestPath);
   const results = [
-    ...files.map((file) => planFileResult(plan, file, targetHome, previousHashes, previousManifest, options)),
+    ...files.map((file) => planFileResult(plan, file, targetHome, previousHashes, previousManifest, options, adoptedHashes, reconciledHashes)),
     ...planStaleFileResults(plan, targetHome, previousManifest, currentRelativePaths, options)
   ];
   assertNotSilentManagedWipeout(plan, results);
@@ -16386,7 +16527,9 @@ function applySessionRenderUnlocked(plan, options, coordination) {
       skippedSources: plan.manifest.skippedSources,
       files: results,
       conflicts,
-      drift
+      drift,
+      adoptions,
+      reconciliations
     };
   }
   let snapshotPath = null;
@@ -16399,10 +16542,12 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   if (!options.dryRun) {
     const allowPortableFallback = coordination === null;
     const forcePortableFileOps = options.test_hooks?.force_portable_file_ops ?? false;
+    assertManifestPrecondition(manifestPath, targetHome, options.expectedManifestSha256);
     ensureSessionTargetHome(targetHome);
-    rollback = writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps);
+    rollback = writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps, adoptions, reconciliations);
     snapshotPath = rollback.snapshotPath;
     options.test_hooks?.before_apply_writes?.({ plan, results });
+    assertManifestPrecondition(manifestPath, targetHome, options.expectedManifestSha256);
     const resultsByPath = new Map(results.map((result) => [result.path, result]));
     for (const file of payloadFiles) {
       applyPlannedFile(plan, file, targetHome, resultsByPath, coordination, allowPortableFallback, forcePortableFileOps);
@@ -16422,7 +16567,7 @@ function applySessionRenderUnlocked(plan, options, coordination) {
       });
       coordination?.assert_held();
     }
-    applyPlannedFile(plan, plan.manifestFile, targetHome, resultsByPath, coordination, allowPortableFallback, forcePortableFileOps);
+    applyPlannedFile(plan, manifestFile, targetHome, resultsByPath, coordination, allowPortableFallback, forcePortableFileOps);
   }
   return {
     dryRun: options.dryRun ?? false,
@@ -16436,8 +16581,170 @@ function applySessionRenderUnlocked(plan, options, coordination) {
     skippedSources: plan.manifest.skippedSources,
     files: results,
     conflicts,
-    drift
+    drift,
+    adoptions,
+    reconciliations
+  };
+}
+function assertManifestPrecondition(path, targetHome, expected) {
+  if (expected === undefined)
+    return;
+  if (!/^[a-f0-9]{64}$/.test(expected)) {
+    throw new SessionApplyError("Expected session manifest SHA-256 must contain 64 lowercase hexadecimal characters.");
+  }
+  if (currentSessionFileHash(path, targetHome) !== expected) {
+    throw new SessionApplyError("Session manifest SHA-256 precondition failed; reload the manifest and resolve a new plan.");
+  }
+}
+function validateFileAdoptions(plan, targetHome, previousHashes, options) {
+  const requests = options.adoptFiles ?? [];
+  if (!Array.isArray(requests))
+    throw new SessionApplyError("Session file adoptions must be an array.");
+  if (requests.length > 0 && options.force) {
+    throw new SessionApplyError("Exact file adoption cannot be combined with force.");
+  }
+  const seen = new Set;
+  return requests.map((request) => {
+    if (!request || typeof request.relativePath !== "string" || typeof request.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(request.sha256)) {
+      throw new SessionApplyError("Each file adoption requires a plan-relative path and a 64-character lowercase SHA-256.");
+    }
+    if (seen.has(request.relativePath)) {
+      throw new SessionApplyError(`Duplicate file adoption target: ${request.relativePath}`);
+    }
+    seen.add(request.relativePath);
+    const candidates = plan.files.filter((file2) => file2.relativePath === request.relativePath);
+    if (candidates.length !== 1 || candidates[0].role === "manifest") {
+      throw new SessionApplyError(`File adoption target is not a unique planned instruction output: ${request.relativePath}`);
+    }
+    const file = candidates[0];
+    const path = resolvePlannedFilePath(plan, file, targetHome);
+    if (previousHashes.has(file.relativePath) || sessionRenderOwnsPath(path)) {
+      throw new SessionApplyError(`File adoption target is already managed: ${request.relativePath}`);
+    }
+    const observedSha256 = readExactFilePreimage(path, targetHome, request, "adoption");
+    return {
+      path,
+      relativePath: file.relativePath,
+      preimageSha256: observedSha256,
+      renderedSha256: file.sha256,
+      sourceIds: [...file.sourceIds]
+    };
+  });
+}
+function readExactFilePreimage(path, targetHome, request, operation) {
+  if (currentSessionFileHash(path, targetHome) === null) {
+    throw new SessionApplyError(`File ${operation} target does not exist: ${request.relativePath}`);
+  }
+  const bytes = readFileSync14(path);
+  if (!bytes.equals(Buffer.from(bytes.toString("utf8"), "utf8"))) {
+    throw new SessionApplyError(`File ${operation} target must contain losslessly restorable UTF-8: ${request.relativePath}`);
+  }
+  const observedSha256 = createHash10("sha256").update(bytes).digest("hex");
+  if (observedSha256 !== request.sha256) {
+    throw new SessionApplyError(`File ${operation} SHA-256 precondition failed: ${request.relativePath}`);
+  }
+  return observedSha256;
+}
+function validateFileReconciliations(plan, targetHome, previousManifest, options) {
+  const requests = options.reconcileFiles ?? [];
+  if (!Array.isArray(requests))
+    throw new SessionApplyError("Session file reconciliations must be an array.");
+  if (requests.length === 0)
+    return [];
+  if (options.force)
+    throw new SessionApplyError("Exact file reconciliation cannot be combined with force.");
+  if (options.expectedManifestSha256 === undefined) {
+    throw new SessionApplyError("Exact file reconciliation requires an expected manifest SHA-256 precondition.");
+  }
+  if (!previousManifest || previousManifest.targetOwner?.writer?.id !== SESSION_RENDERER_OWNER_ID || previousManifest.tool !== plan.tool || previousManifest.targetHome !== targetHome) {
+    throw new SessionApplyError("File reconciliation requires this renderer's manifest for the same tool and target home.");
+  }
+  const seen = new Set;
+  return requests.map((request) => {
+    if (!request || typeof request.relativePath !== "string" || typeof request.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(request.sha256)) {
+      throw new SessionApplyError("Each file reconciliation requires a plan-relative path and a 64-character lowercase SHA-256.");
+    }
+    if (seen.has(request.relativePath)) {
+      throw new SessionApplyError(`Duplicate file reconciliation target: ${request.relativePath}`);
+    }
+    seen.add(request.relativePath);
+    const candidates = plan.files.filter((file2) => file2.relativePath === request.relativePath);
+    if (candidates.length !== 1 || candidates[0].role === "manifest") {
+      throw new SessionApplyError(`File reconciliation target is not a unique planned instruction output: ${request.relativePath}`);
+    }
+    const file = candidates[0];
+    const path = resolvePlannedFilePath(plan, file, targetHome);
+    const owned = previousManifest.files.filter((entry) => entry.relativePath === file.relativePath);
+    if (owned.length !== 1 || owned[0].path !== path || owned[0].role !== file.role || !/^[a-f0-9]{64}$/.test(owned[0].sha256)) {
+      throw new SessionApplyError(`File reconciliation target is not owned by the observed manifest: ${request.relativePath}`);
+    }
+    const observedSha256 = readExactFilePreimage(path, targetHome, request, "reconciliation");
+    if (observedSha256 === owned[0].sha256) {
+      throw new SessionApplyError(`File reconciliation target has no managed drift: ${request.relativePath}`);
+    }
+    if (observedSha256 === file.sha256) {
+      throw new SessionApplyError(`File reconciliation target already matches the planned output: ${request.relativePath}`);
+    }
+    return {
+      path,
+      relativePath: file.relativePath,
+      preimageSha256: observedSha256,
+      renderedSha256: file.sha256,
+      previousManagedSha256: owned[0].sha256,
+      sourceIds: [...file.sourceIds]
+    };
+  });
+}
+function manifestWithFileProvenance(plan, previousManifest, adoptions, reconciliations) {
+  if (adoptions.length === 0 && previousManifest?.adoptions === undefined && reconciliations.length === 0 && previousManifest?.reconciliations === undefined)
+    return plan.manifestFile;
+  if (previousManifest?.adoptions !== undefined && !Array.isArray(previousManifest.adoptions)) {
+    throw new SessionApplyError("Previous session manifest adoption provenance is invalid.");
+  }
+  const entries = new Map;
+  for (const entry of [
+    ...previousManifest?.adoptions ?? [],
+    ...adoptions.map(({ path: _path, ...receipt }) => receipt)
+  ]) {
+    if (!entry || typeof entry.relativePath !== "string" || !/^[a-f0-9]{64}$/.test(entry.preimageSha256) || !/^[a-f0-9]{64}$/.test(entry.renderedSha256) || !Array.isArray(entry.sourceIds) || entry.sourceIds.some((id) => typeof id !== "string")) {
+      throw new SessionApplyError("Previous session manifest adoption provenance is invalid.");
+    }
+    resolveManifestRelativePath(entry.relativePath, plan.targetHome);
+    const previous = entries.get(entry.relativePath);
+    if (previous && JSON.stringify(previous) !== JSON.stringify(entry)) {
+      throw new SessionApplyError(`Conflicting session file adoption provenance: ${entry.relativePath}`);
+    }
+    entries.set(entry.relativePath, entry);
+  }
+  if (previousManifest?.reconciliations !== undefined && !Array.isArray(previousManifest.reconciliations)) {
+    throw new SessionApplyError("Previous session manifest reconciliation provenance is invalid.");
+  }
+  const reconciledEntries = new Map;
+  for (const entry of [
+    ...previousManifest?.reconciliations ?? [],
+    ...reconciliations.map(({ path: _path, ...receipt }) => receipt)
+  ]) {
+    if (!entry || typeof entry.relativePath !== "string" || !/^[a-f0-9]{64}$/.test(entry.preimageSha256) || !/^[a-f0-9]{64}$/.test(entry.renderedSha256) || !/^[a-f0-9]{64}$/.test(entry.previousManagedSha256) || !Array.isArray(entry.sourceIds) || entry.sourceIds.some((id) => typeof id !== "string")) {
+      throw new SessionApplyError("Previous session manifest reconciliation provenance is invalid.");
+    }
+    resolveManifestRelativePath(entry.relativePath, plan.targetHome);
+    const canonical = {
+      relativePath: entry.relativePath,
+      preimageSha256: entry.preimageSha256,
+      renderedSha256: entry.renderedSha256,
+      previousManagedSha256: entry.previousManagedSha256,
+      sourceIds: [...entry.sourceIds]
+    };
+    reconciledEntries.set(JSON.stringify(canonical), canonical);
+  }
+  const manifest = {
+    ...plan.manifest,
+    ...adoptions.length > 0 || previousManifest?.adoptions !== undefined ? { adoptions: [...entries.values()] } : {},
+    ...reconciliations.length > 0 || previousManifest?.reconciliations !== undefined ? { reconciliations: [...reconciledEntries.values()] } : {}
   };
+  const content = `${JSON.stringify(manifest, null, 2)}
+`;
+  return { ...plan.manifestFile, content, sha256: sha25610(content) };
 }
 function assertCursorAuthorityUnchanged(plan) {
   if (plan.tool !== "cursor" || plan.targetKind === "blocked")
@@ -16910,12 +17217,29 @@ function resolveSnapshotFilePath(relativePath, recordedPath, targetHome) {
   }
   return path;
 }
-function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options) {
+function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options, adoptedHashes, reconciledHashes) {
   const target = resolvePlannedFilePath(plan, file, targetHome);
   const previousContent = existsSync15(target) ? readFileSync14(target, "utf-8") : null;
   const previousSha256 = previousContent === null ? null : sha25610(previousContent);
   const previouslyManaged = isPreviouslyManaged(file, previousSha256, previousHashes, previousManifest);
   const changed = previousContent !== file.content;
+  const exactSha256 = adoptedHashes.get(file.relativePath) ?? reconciledHashes.get(file.relativePath);
+  if (exactSha256 !== undefined) {
+    const operation = adoptedHashes.has(file.relativePath) ? "adoption" : "reconciliation";
+    if (previousSha256 !== exactSha256) {
+      throw new SessionApplyError(`File ${operation} SHA-256 precondition failed: ${file.relativePath}`);
+    }
+    return {
+      path: target,
+      relativePath: file.relativePath,
+      role: file.role,
+      action: "update",
+      changed,
+      previousSha256,
+      newSha256: file.sha256,
+      reason: `exact observed SHA-256 ${operation}`
+    };
+  }
   if (previousContent !== null && !options.force && !previouslyManaged) {
     return {
       path: target,
@@ -17135,9 +17459,13 @@ function requiredPreviousHash(result) {
   }
   return result.previousSha256;
 }
-function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps) {
-  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").filter((result) => existsSync15(result.path)).map((result) => {
+function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps, adoptions, reconciliations) {
+  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").map((result) => {
+    assertExpectedSessionFileHash(result.path, targetHome, result.previousSha256);
     const content = readFileSync14(result.path, "utf-8");
+    if (sha25610(content) !== result.previousSha256) {
+      throw new SessionApplyError(`Session snapshot preimage changed after planning: ${result.relativePath}`);
+    }
     return {
       path: result.path,
       relativePath: result.relativePath,
@@ -17178,13 +17506,19 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
     manifestPath,
     previousManifest,
     files: existingFiles,
-    afterFiles
+    afterFiles,
+    ...adoptions.length > 0 ? { adoptions } : {},
+    ...reconciliations.length > 0 ? { reconciliations } : {}
   };
+  const snapshotContent = `${JSON.stringify(snapshot, null, 2)}
+`;
+  if ((adoptions.length > 0 || reconciliations.length > 0) && Buffer.byteLength(snapshotContent, "utf8") > 32 * 1024 * 1024) {
+    throw new SessionApplyError("Exact file preimage snapshot exceeds the 32 MiB restore limit.");
+  }
   coordination?.assert_held();
   writeProjectContextCoordinatedFile({
     path: snapshotPath,
-    content: `${JSON.stringify(snapshot, null, 2)}
-`,
+    content: snapshotContent,
     workspace_root: sessionRenderSnapshotWorkspaceRoot(targetHome),
     default_mode: 384,
     expected_hash: null,
@@ -17241,6 +17575,211 @@ function assertNoSymlinkAncestors3(path) {
 function sha25610(content) {
   return createHash10("sha256").update(content).digest("hex");
 }
+// src/lib/session-refresh.ts
+init_zod();
+import { createHash as createHash11 } from "crypto";
+import { closeSync as closeSync4, constants as constants2, fstatSync as fstatSync4, lstatSync as lstatSync7, openSync as openSync4, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname11, join as join18, parse as parse6, resolve as resolve12 } from "path";
+
+// src/lib/global-source-coverage.ts
+var GLOBAL_SOURCE_SLUG_PREFIX = "global-";
+function expectedGlobalSourceSlugs(registryConfigs) {
+  return registryConfigs.filter((c) => c.slug.startsWith(GLOBAL_SOURCE_SLUG_PREFIX)).filter((c) => instructionSourceRejection(c) === null).map((c) => c.slug).sort();
+}
+function accountedGlobalSourceSlugs(manifest) {
+  return [...manifest.sources, ...manifest.skippedSources].map((source) => source.id).filter((id) => id.startsWith(GLOBAL_SOURCE_SLUG_PREFIX));
+}
+function computeGlobalSourceCoverage(registryConfigs, configuredSlugs) {
+  const expected = expectedGlobalSourceSlugs(registryConfigs);
+  const expectedSet = new Set(expected);
+  const configuredSet = new Set(configuredSlugs);
+  const missing = expected.filter((slug2) => !configuredSet.has(slug2));
+  const unexpected = [...configuredSet].filter((slug2) => slug2.startsWith(GLOBAL_SOURCE_SLUG_PREFIX) && !expectedSet.has(slug2)).sort();
+  return {
+    expectedSlugs: expected,
+    excludedSources: registryConfigs.filter((config) => config.slug.startsWith(GLOBAL_SOURCE_SLUG_PREFIX)).flatMap((config) => {
+      const reason = instructionSourceRejection(config);
+      return reason ? [{ slug: config.slug, reason }] : [];
+    }).sort((left, right) => left.slug.localeCompare(right.slug)),
+    configuredSlugs: [...configuredSet].sort(),
+    missingSlugs: missing,
+    unexpectedSlugs: unexpected,
+    complete: missing.length === 0
+  };
+}
+
+// src/lib/session-refresh.ts
+init_instruction_graph();
+init_project_context();
+init_session_render();
+import { basename as basename6 } from "path";
+var nonempty = exports_external.string().min(1).max(4096);
+var selectorSchema = exports_external.object({
+  schema: exports_external.literal("hasna.instructions.hosted-profile-selector/v1"),
+  authority: nonempty,
+  profileId: nonempty,
+  providerVersion: nonempty,
+  providerVariant: nonempty.optional(),
+  model: nonempty.optional(),
+  path: nonempty.optional(),
+  manual: exports_external.array(nonempty).max(256),
+  codewithNativeImports: exports_external.boolean(),
+  allowEmptySources: exports_external.boolean(),
+  stationProfile: exports_external.boolean(),
+  checkGlobalCoverage: exports_external.boolean(),
+  assetSurface: nonempty.optional(),
+  assetScope: exports_external.enum(["global", "project", "session"]).optional()
+}).strict();
+function authority(value) {
+  const url = new URL(value);
+  if (url.username || url.password || url.search || url.hash || !["https:", "http:"].includes(url.protocol)) {
+    throw new Error("SESSION_REFRESH_AUTHORITY_INVALID: expected a credential-free Instructions API authority.");
+  }
+  return url.toString().replace(/\/$/, "");
+}
+function normalizeSessionHostedProfileSelector(value) {
+  const parsed = selectorSchema.parse(value);
+  return { ...parsed, authority: authority(parsed.authority) };
+}
+function assertHostedProfileBindings(profileId, configs, bindings) {
+  const configIds = new Set(configs.map((config) => config.id));
+  const bindingIds = new Set(bindings.map((binding) => binding.config_id));
+  if (configIds.size !== configs.length || bindingIds.size !== bindings.length || bindings.some((binding) => binding.profile_id !== profileId || !configIds.has(binding.config_id)) || [...configIds].some((id) => !bindingIds.has(id))) {
+    throw new Error("HOSTED_PROFILE_BINDINGS_INCOMPLETE: exact one-to-one config membership and explicit profile bindings are required; refusing legacy activation fallback.");
+  }
+  for (const row of bindings) {
+    const raw = row.binding;
+    const invalid = () => new Error("HOSTED_PROFILE_BINDINGS_INVALID: each hosted binding must contain a complete explicit schema, activation, required flag and fallback; refusing legacy activation defaults.");
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+      throw invalid();
+    const record = raw;
+    if (!["schema", "activation", "required", "fallback"].every((key) => Object.hasOwn(record, key)) || typeof record["required"] !== "boolean")
+      throw invalid();
+    try {
+      normalizeProfileConfigBinding(record);
+    } catch {
+      throw invalid();
+    }
+  }
+}
+function readManagedManifest(targetHome) {
+  const path = join18(targetHome, SESSION_RENDER_MANIFEST_RELATIVE_PATH);
+  let ancestor = dirname11(path);
+  while (true) {
+    const stat = lstatSync7(ancestor);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+      throw new Error("SESSION_REFRESH_PATH_INVALID: managed target uses a symlink or non-directory ancestor.");
+    const parent = dirname11(ancestor);
+    if (parent === ancestor)
+      break;
+    ancestor = parent;
+  }
+  const fd = openSync4(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+  let raw;
+  try {
+    const stat = fstatSync4(fd);
+    if (!stat.isFile() || stat.size > SESSION_MANAGED_INPUT_MAX_BYTES)
+      throw new Error("SESSION_REFRESH_MANIFEST_INVALID: expected a bounded regular manifest file.");
+    raw = readFileSync15(fd);
+    if (raw.byteLength > SESSION_MANAGED_INPUT_MAX_BYTES)
+      throw new Error("SESSION_REFRESH_MANIFEST_INVALID: manifest grew beyond the read limit.");
+  } finally {
+    closeSync4(fd);
+  }
+  const manifest = JSON.parse(raw.toString("utf8"));
+  if (manifest.schema !== SESSION_RENDER_SCHEMA || !SESSION_RENDER_TOOLS.includes(manifest.tool) || manifest.targetHome !== targetHome || !manifest.profile?.trim() || !["session-home", "project-root"].includes(manifest.targetKind) || !Array.isArray(manifest.files) || !manifest.refreshSelector || manifest.targetOwner?.writer?.id !== SESSION_RENDERER_OWNER_ID || manifest.targetOwner?.targetHome !== targetHome) {
+    throw new Error("SESSION_REFRESH_MANIFEST_INVALID: target is not an owned hosted profile render; apply a hosted --compile-profile first.");
+  }
+  manifest.refreshSelector = normalizeSessionHostedProfileSelector(manifest.refreshSelector);
+  return { manifest, sha256: createHash11("sha256").update(raw).digest("hex") };
+}
+async function refreshSessionRender(input) {
+  const { store } = input;
+  if (store.mode !== "api" || !store.v1BaseUrl)
+    throw new Error("SESSION_REFRESH_HOSTED_REQUIRED: refresh requires the configured hosted Instructions API.");
+  const targetHome = resolve12(input.targetHome);
+  if (targetHome === parse6(targetHome).root)
+    throw new Error("SESSION_REFRESH_PATH_INVALID: filesystem root is not a managed target.");
+  const previous = readManagedManifest(targetHome);
+  const selector = previous.manifest.refreshSelector;
+  if (authority(store.v1BaseUrl) !== selector.authority)
+    throw new Error("SESSION_REFRESH_AUTHORITY_MISMATCH: configured API differs from the recorded profile authority.");
+  const profile = await store.getProfile(selector.profileId);
+  if (profile.id !== selector.profileId)
+    throw new Error("SESSION_REFRESH_PROFILE_MISMATCH: hosted profile identity changed.");
+  const [configs, bindings, assetBindings] = await Promise.all([
+    store.getProfileConfigs(profile.id),
+    store.getProfileConfigBindings(profile.id, { requireExplicit: true }),
+    store.getProfileAssetBindings(profile.id, { requireExplicit: true })
+  ]);
+  assertHostedProfileBindings(profile.id, configs, bindings);
+  if (configs.length > 2048 || bindings.length > 8192 || assetBindings.length > 1024)
+    throw new Error("SESSION_REFRESH_INPUT_LIMIT: hosted profile exceeds refresh bounds.");
+  const totalBytes = configs.reduce((sum, config) => sum + Buffer.byteLength(config.content), 0);
+  if (totalBytes > SESSION_MANAGED_INPUT_MAX_BYTES)
+    throw new Error("SESSION_REFRESH_INPUT_LIMIT: hosted instruction payload exceeds refresh byte bounds.");
+  const assetConfigs = await Promise.all([...new Set(assetBindings.map((binding) => binding.source_config_id))].map((id) => store.getConfigById(id)));
+  if (assetConfigs.reduce((sum, config) => sum + Buffer.byteLength(config.content), totalBytes) > SESSION_MANAGED_INPUT_MAX_BYTES)
+    throw new Error("SESSION_REFRESH_INPUT_LIMIT: hosted source and asset payload exceeds refresh byte bounds.");
+  let ownedClaudeAuthorities;
+  if (previous.manifest.tool === "claude") {
+    ownedClaudeAuthorities = (await store.listConfigs({ category: "rules", agent: "claude", kind: "file" })).filter((config) => config.target_path && basename6(normalizeTargetPath(config.target_path)) === "AGENTS.md").map((config) => ({ slug: config.slug, targetPath: config.target_path, content: config.content }));
+  }
+  const station = selector.stationProfile ? stationProfileSource() : null;
+  const plan = planProfileSessionRender({
+    tool: previous.manifest.tool,
+    profile: previous.manifest.profile,
+    profile_id: profile.id,
+    provider_version: selector.providerVersion,
+    targetHome,
+    ...previous.manifest.targetKind === "project-root" ? { projectRoot: targetHome } : {},
+    sessionId: previous.manifest.sessionId ?? undefined,
+    refreshSelector: selector,
+    codewithNativeImports: selector.codewithNativeImports,
+    allowEmptySources: selector.allowEmptySources,
+    configs,
+    bindings,
+    asset_configs: assetConfigs,
+    asset_bindings: assetBindings,
+    asset_plan_mode: input.dryRun ? "dry-run" : "apply",
+    asset_scope: selector.assetScope,
+    asset_surface: selector.assetSurface,
+    extra_sources: station ? [station] : undefined,
+    ownedClaudeAuthorities,
+    graph_context: {
+      ...selector.providerVariant ? { provider_variant: selector.providerVariant } : {},
+      ...selector.model ? { model: selector.model } : {},
+      ...selector.path ? { path: selector.path } : {},
+      ...selector.manual.length ? { manual: selector.manual } : {}
+    }
+  });
+  if (selector.checkGlobalCoverage) {
+    const coverage = computeGlobalSourceCoverage(await store.listConfigs({}), accountedGlobalSourceSlugs(plan.manifest));
+    if (!coverage.complete)
+      throw new Error(`SESSION_REFRESH_COVERAGE_INCOMPLETE: ${coverage.missingSlugs.length} registered global sources are absent.`);
+  }
+  const preview = applySessionRender(plan, { dryRun: true, expectedManifestSha256: previous.sha256, ownedClaudeAuthorities });
+  const common = { checkedAt: new Date().toISOString(), targetHome, selector, sourceHash: plan.manifest.sourceHash };
+  if (preview.conflicts.length)
+    return { ...common, status: "blocked", apply: preview };
+  if (!preview.drift.clean)
+    throw new Error("SESSION_REFRESH_DRIFT: generated files changed or disappeared since their last managed render.");
+  const sameSources = previous.manifest.sourceHash === plan.manifest.sourceHash;
+  const samePayloads = preview.files.filter((file) => file.role !== "manifest").every((file) => file.action === "unchanged");
+  if (sameSources && samePayloads) {
+    if (readManagedManifest(targetHome).sha256 !== previous.sha256 || !checkSessionRenderDrift(targetHome).clean)
+      throw new Error("SESSION_REFRESH_DRIFT: managed target changed during refresh.");
+    return { ...common, status: "unchanged", apply: { ...preview, files: preview.files.map((file) => file.role === "manifest" ? { ...file, action: "unchanged", changed: false, newSha256: previous.sha256, reason: "hosted sources and generated payloads unchanged" } : file) } };
+  }
+  if (input.dryRun)
+    return { ...common, status: "dry-run", apply: preview };
+  const applied = applySessionRender(plan, { expectedManifestSha256: previous.sha256, ownedClaudeAuthorities });
+  if (applied.conflicts.length)
+    return { ...common, status: "blocked", apply: applied };
+  if (!applied.applied || !checkSessionRenderDrift(targetHome).clean)
+    throw new Error("SESSION_REFRESH_READBACK_FAILED: applied instructions did not verify against their manifest.");
+  return { ...common, status: "updated", apply: applied };
+}
 
 // src/index.ts
 init_project_context();
@@ -17248,9 +17787,11 @@ init_transforms();
 init_machine();
 
 // src/lib/platform-profiles.ts
+init_types();
 init_config_store();
 
 // src/lib/project-dashboard-standard.ts
+init_types();
 init_config_store();
 var PROJECT_DASHBOARD_STANDARD_SLUG = "agent-managed-project-dashboard-standard";
 var PROJECT_DASHBOARD_PROFILE_VARIABLES = {
@@ -17343,11 +17884,15 @@ async function ensureProjectDashboardStandardConfig(store = resolveConfigStore()
   };
   try {
     const existing = await store.getConfig(PROJECT_DASHBOARD_STANDARD_SLUG);
+    if (isRetiredInstructionSource(existing))
+      return existing;
     if (existing.content !== input.content || existing.description !== input.description || existing.category !== input.category || existing.agent !== input.agent || existing.format !== input.format || existing.kind !== input.kind) {
       return await store.updateConfig(existing.id, input);
     }
     return existing;
-  } catch {
+  } catch (error) {
+    if (!(error instanceof ConfigNotFoundError))
+      throw error;
     return await store.createConfig(input);
   }
 }
@@ -17360,10 +17905,9 @@ function profileHasSelectors2(profile) {
 var PLATFORM_PROFILE_PRESETS = [
   {
     name: "linux-arm64",
-    description: "Default Linux arm64 profile for linux-node-a/linux-node-b-style machines",
-    selectors: { os: ["linux"], arch: ["arm64"], hostnames: ["linux-node-a", "linux-node-b", "station01"] },
+    description: "Default reviewed instruction profile for Linux arm64",
+    selectors: { os: ["linux"], arch: ["arm64"] },
     variables: {
-      WORKSPACE_ROOT: "{{HOME_DIR}}/workspace",
       BUN_BIN_DIR: "{{HOME_DIR}}/.bun/bin",
       BUN_PATH: "{{BUN_BIN_DIR}}/bun",
       PATH_PREFIX: "{{BUN_BIN_DIR}}",
@@ -17372,10 +17916,9 @@ var PLATFORM_PROFILE_PRESETS = [
   },
   {
     name: "macos-arm64",
-    description: "Default macOS arm64 profile for macos-node-a/macos-node-b-style machines",
-    selectors: { os: ["macos"], arch: ["arm64"], hostnames: ["macos-node-a", "macos-node-b"] },
+    description: "Default reviewed instruction profile for macOS arm64",
+    selectors: { os: ["macos"], arch: ["arm64"] },
     variables: {
-      WORKSPACE_ROOT: "{{HOME_DIR}}/Workspace",
       BUN_BIN_DIR: "{{HOME_DIR}}/.bun/bin",
       BUN_PATH: "/opt/homebrew/bin/bun",
       PATH_PREFIX: "/opt/homebrew/bin:{{BUN_BIN_DIR}}",
@@ -17384,12 +17927,21 @@ var PLATFORM_PROFILE_PRESETS = [
   }
 ];
 async function ensurePlatformProfiles(store = resolveConfigStore()) {
-  const configs = await store.listConfigs();
   const ensured = [];
-  for (const preset of PLATFORM_PROFILE_PRESETS) {
-    let profile;
+  const existingProfiles = await Promise.all(PLATFORM_PROFILE_PRESETS.map(async (preset) => {
     try {
-      profile = await store.getProfile(preset.name);
+      return await store.getProfile(preset.name);
+    } catch (error) {
+      if (error instanceof ProfileNotFoundError)
+        return null;
+      throw error;
+    }
+  }));
+  for (const [index, preset] of PLATFORM_PROFILE_PRESETS.entries()) {
+    let profile;
+    const existing = existingProfiles[index];
+    if (existing) {
+      profile = existing;
       const selectors = mergeProfileSelectors(preset.selectors, profile.selectors);
       const variables = mergeProfileVariables(preset.variables, profile.variables);
       if (JSON.stringify(selectors) !== JSON.stringify(profile.selectors) || JSON.stringify(variables) !== JSON.stringify(profile.variables)) {
@@ -17399,12 +17951,9 @@ async function ensurePlatformProfiles(store = resolveConfigStore()) {
           variables
         });
       }
-    } catch {
+    } else {
       profile = await store.createProfile(preset);
     }
-    for (const config of configs) {
-      await store.addConfigToProfile(profile.id, config.id);
-    }
     ensured.push(profile);
   }
   return ensured;
@@ -17438,6 +17987,7 @@ function mergeUnique(preset, existing) {
 init_global_agent_rules_standard();
 
 // src/lib/dangerous-operation-guard-standard.ts
+init_types();
 init_config_store();
 var DANGEROUS_OPERATION_GUARD_STANDARD_SLUG = "dangerous-operation-guard-standard";
 var DANGEROUS_OPERATION_GUARD_STANDARD_CONTENT = `# Dangerous Operation Guard Standard
@@ -17549,11 +18099,15 @@ async function ensureDangerousOperationGuardStandardConfig(store = resolveConfig
   };
   try {
     const existing = await store.getConfig(DANGEROUS_OPERATION_GUARD_STANDARD_SLUG);
+    if (isRetiredInstructionSource(existing))
+      return existing;
     if (existing.content !== input.content || existing.description !== input.description || existing.category !== input.category || existing.agent !== input.agent || existing.format !== input.format || existing.kind !== input.kind || JSON.stringify(existing.tags) !== JSON.stringify(input.tags)) {
       return await store.updateConfig(existing.id, input);
     }
     return existing;
-  } catch {
+  } catch (error) {
+    if (!(error instanceof ConfigNotFoundError))
+      throw error;
     return await store.createConfig(input);
   }
 }
@@ -17563,8 +18117,8 @@ init_codewith_shared_todos_storage_standard();
 
 // src/lib/sync.ts
 init_config_store();
-import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync16 } from "fs";
-import { basename as basename6, extname as extname3, join as join19 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync17 } from "fs";
+import { basename as basename7, extname as extname3, join as join20 } from "path";
 init_config_agents();
 init_redact();
 init_machine();
@@ -17572,8 +18126,8 @@ init_transforms();
 
 // src/lib/sync-dir.ts
 init_config_store();
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
-import { join as join18, relative as relative7 } from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync16, statSync as statSync6 } from "fs";
+import { join as join19, relative as relative7 } from "path";
 init_redact();
 var SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
 function shouldSkip(p) {
@@ -17584,7 +18138,7 @@ async function syncFromDir(dir, opts = {}) {
   const absDir = expandPath(dir);
   if (!existsSync16(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync4(absDir).map((f) => join18(absDir, f)).filter((f) => statSync6(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync4(absDir).map((f) => join19(absDir, f)).filter((f) => statSync6(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
   const allConfigs = await store.listConfigs();
   for (const file of files) {
@@ -17593,7 +18147,7 @@ async function syncFromDir(dir, opts = {}) {
       continue;
     }
     try {
-      const content = readFileSync15(file, "utf-8");
+      const content = readFileSync16(file, "utf-8");
       if (content.length > 500000) {
         result.skipped.push(file + " (too large)");
         continue;
@@ -17643,7 +18197,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-    const full = join18(dir, entry.name);
+    const full = join19(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -17665,7 +18219,7 @@ var CLAUDE_PROMPT_OUTPUTS = [
   { agent: "qwen", target_path: "~/.qwen/QWEN.md", transform: "codex-flat" }
 ];
 function claudeRuleOutputs(fileName) {
-  const stem = basename6(fileName, extname3(fileName));
+  const stem = basename7(fileName, extname3(fileName));
   return [
     { agent: "cursor", target_path: `~/.cursor/rules/${stem}.mdc`, transform: "cursor-mdc" }
   ];
@@ -17711,7 +18265,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   const absolutePrefix = expandPath("~/.cursor/rules");
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
-  const stem = basename6(absoluteTargetPath, ".mdc");
+  const stem = basename7(absoluteTargetPath, ".mdc");
   return existsSync17(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync17(expandPath(`~/.claude/rules/${stem}.mdc`));
 }
 function isKnownGeneratedTargetPath(targetPath) {
@@ -17777,11 +18331,11 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join19(absDir, pf.file);
+    const abs = join20(absDir, pf.file);
     if (!existsSync17(abs))
       continue;
     try {
-      const rawContent = readFileSync16(abs, "utf-8");
+      const rawContent = readFileSync17(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(pf.file);
         continue;
@@ -17810,20 +18364,20 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join19(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join19(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
-    { dir: join19(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
-    { dir: join19(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
-    { dir: join19(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
-    { dir: join19(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
-    { dir: join19(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
+    { dir: join20(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join20(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
+    { dir: join20(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
+    { dir: join20(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
+    { dir: join20(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
+    { dir: join20(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
+    { dir: join20(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
   ]) {
     if (!existsSync17(ruleDir.dir))
       continue;
     const mdFiles = readdirSync5(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join19(ruleDir.dir, f);
-      const raw = readFileSync16(abs, "utf-8");
+      const abs = join20(ruleDir.dir, f);
+      const raw = readFileSync17(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
@@ -17869,13 +18423,13 @@ async function syncKnown(opts = {}) {
       const extensions = known.rulesExtensions ?? [".md", ".mdc"];
       const ruleFiles = readdirSync5(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join19(absDir, f);
+        const abs2 = join20(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
           continue;
         }
-        const raw = readFileSync16(abs2, "utf-8");
+        const raw = readFileSync17(abs2, "utf-8");
         const redacted = redactContent(raw, "markdown");
         const machineAware = templateizeMachineContent(redacted.content, machine);
         const content = machineAware.content;
@@ -17908,7 +18462,7 @@ async function syncKnown(opts = {}) {
       continue;
     }
     try {
-      const rawContent = normalizeKnownConfigSource(known, readFileSync16(abs, "utf-8"));
+      const rawContent = normalizeKnownConfigSource(known, readFileSync17(abs, "utf-8"));
       if (rawContent.length > 500000) {
         result.skipped.push(known.path + " (too large)");
         continue;
@@ -18013,7 +18567,7 @@ function buildDiff(expectedContent, targetPath, storedFormat, showSecrets) {
   const path = expandPath(targetPath);
   if (!existsSync17(path))
     return `(file not found on disk: ${path})`;
-  const diskContent = readFileSync16(path, "utf-8");
+  const diskContent = readFileSync17(path, "utf-8");
   if (diskContent === expectedContent)
     return "(no diff \u2014 identical)";
   const format = redactFormatForTarget(targetPath, storedFormat);
@@ -18173,9 +18727,9 @@ function detectFormat(filePath) {
 // src/lib/export.ts
 init_types();
 init_config_store();
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash12 } from "crypto";
 import { existsSync as existsSync18, mkdirSync as mkdirSync8, mkdtempSync, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname11, join as join20, resolve as resolve12 } from "path";
+import { dirname as dirname12, join as join21, resolve as resolve13 } from "path";
 import { tmpdir } from "os";
 var ARCHIVE_EXCLUSIONS = [
   {
@@ -18198,7 +18752,7 @@ function compareText(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 function sha25611(value) {
-  return createHash11("sha256").update(value).digest("hex");
+  return createHash12("sha256").update(value).digest("hex");
 }
 function canonicalize(value) {
   if (Array.isArray(value))
@@ -18511,13 +19065,13 @@ async function exportConfigs(outputPath, opts = {}) {
     integrity,
     exclusions: ARCHIVE_EXCLUSIONS
   };
-  const absOutput = resolve12(outputPath);
-  mkdirSync8(dirname11(absOutput), { recursive: true });
-  const stagingDir = mkdtempSync(join20(tmpdir(), "instructions-domain-export-"));
+  const absOutput = resolve13(outputPath);
+  mkdirSync8(dirname12(absOutput), { recursive: true });
+  const stagingDir = mkdtempSync(join21(tmpdir(), "instructions-domain-export-"));
   try {
-    writeFileSync6(join20(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    writeFileSync6(join21(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
-    writeFileSync6(join20(stagingDir, "domain.json"), payload, "utf-8");
+    writeFileSync6(join21(stagingDir, "domain.json"), payload, "utf-8");
     const proc = Bun.spawn(["tar", "czf", absOutput, "-C", stagingDir, "manifest.json", "domain.json"], {
       stdout: "pipe",
       stderr: "pipe"
@@ -18536,8 +19090,8 @@ async function exportConfigs(outputPath, opts = {}) {
 // src/lib/import.ts
 init_types();
 init_config_store();
-import { createHash as createHash12 } from "crypto";
-import { resolve as resolve13 } from "path";
+import { createHash as createHash13 } from "crypto";
+import { resolve as resolve14 } from "path";
 function compareText2(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
@@ -18562,7 +19116,7 @@ function emptyResult() {
   };
 }
 function sha25612(value) {
-  return createHash12("sha256").update(value).digest("hex");
+  return createHash13("sha256").update(value).digest("hex");
 }
 function normalizeMemberName(name) {
   let normalized = name;
@@ -18825,7 +19379,7 @@ async function importV1(reader, manifest, store, conflict) {
 async function importConfigs(bundlePath, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const conflict = opts.conflict ?? "skip";
-  const reader = await openArchive(resolve13(bundlePath));
+  const reader = await openArchive(resolve14(bundlePath));
   const manifestText = await reader.read("manifest.json");
   let manifest;
   try {
@@ -18853,9 +19407,9 @@ init_redact();
 
 // src/lib/package-manager-guard.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync19, lstatSync as lstatSync7, readdirSync as readdirSync6, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync19, lstatSync as lstatSync8, readdirSync as readdirSync6, readFileSync as readFileSync18 } from "fs";
 import { homedir as homedir10 } from "os";
-import { basename as basename7, dirname as dirname12, isAbsolute as isAbsolute8, join as join21, relative as relative8, resolve as resolve14 } from "path";
+import { basename as basename8, dirname as dirname13, isAbsolute as isAbsolute8, join as join22, relative as relative8, resolve as resolve15 } from "path";
 var SKIP_DIRS = new Set([
   ".git",
   "node_modules",
@@ -18892,14 +19446,14 @@ var TOKEN_VALUE_PATTERNS = [
   { re: /xoxb-[0-9]+-[A-Za-z0-9-]+/, rule: "literal-slack-token", detail: "literal Slack token-like value" }
 ];
 function scanPackageManagerSecrets(options = {}) {
-  const cwd = options.cwd ? resolve14(options.cwd) : process.cwd();
-  const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve14(cwd, root));
+  const cwd = options.cwd ? resolve15(options.cwd) : process.cwd();
+  const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve15(cwd, root));
   const findings = [];
   let scannedFiles = 0;
   for (const root of roots) {
     if (!existsSync19(root))
       continue;
-    const stat = lstatSync7(root);
+    const stat = lstatSync8(root);
     if (stat.isFile()) {
       if (!shouldScanRepoFile(root))
         continue;
@@ -18907,7 +19461,7 @@ function scanPackageManagerSecrets(options = {}) {
       if (text === null)
         continue;
       scannedFiles++;
-      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname12(root)));
+      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname13(root)));
       continue;
     }
     if (!stat.isDirectory())
@@ -18926,7 +19480,7 @@ function scanPackageManagerSecrets(options = {}) {
   if (options.includeHome) {
     const home = homedir10();
     for (const name of HOME_FILES) {
-      const file = join21(home, name);
+      const file = join22(home, name);
       if (!existsSync19(file))
         continue;
       const text = readTextFile(file);
@@ -18951,12 +19505,12 @@ function collectRepoFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
           continue;
-        visit(join21(dir, entry.name));
+        visit(join22(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const file = join21(dir, entry.name);
+      const file = join22(dir, entry.name);
       if (shouldScanRepoFile(file))
         out.push(file);
     }
@@ -18965,11 +19519,11 @@ function collectRepoFiles(root) {
   return out;
 }
 function shouldScanRepoFile(file) {
-  const name = basename7(file);
+  const name = basename8(file);
   return isNpmrcName(name) || isBunConfigName(name) || LOCKFILE_NAMES.has(name);
 }
 function classifyRepoFile(file) {
-  const name = basename7(file);
+  const name = basename8(file);
   if (isNpmrcName(name))
     return "repo-npmrc";
   if (isBunConfigName(name))
@@ -18991,10 +19545,10 @@ function isNpmrcName(name) {
 }
 function readTextFile(file) {
   try {
-    const stat = lstatSync7(file);
+    const stat = lstatSync8(file);
     if (!stat.isFile() || stat.size > 5000000)
       return null;
-    const buf = readFileSync17(file);
+    const buf = readFileSync18(file);
     if (buf.includes(0))
       return null;
     return buf.toString("utf-8");
@@ -19194,7 +19748,7 @@ function trackedFiles(root) {
 }
 function isTrackedFile(file) {
   try {
-    const repoRoot = execFileSync2("git", ["-C", dirname12(file), "rev-parse", "--show-toplevel"], {
+    const repoRoot = execFileSync2("git", ["-C", dirname13(file), "rev-parse", "--show-toplevel"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -19237,6 +19791,7 @@ function toPosix(path) {
   return path.split("\\").join("/");
 }
 export {
+  validateExpectedConfigVersion,
   uuid,
   transformSkillContent,
   templateizeMachineContent,
@@ -19272,6 +19827,7 @@ export {
   renderMachineAwareContentPreview,
   renderMachineAwareContent,
   refreshStationProfile,
+  refreshSessionRender,
   redactContent,
   reconcileManagedSkillRuntimes,
   readStationProfile,
@@ -19285,6 +19841,7 @@ export {
   parseProjectContextBundle,
   parseAgentOperatingRulesVersion,
   now,
+  normalizeSessionHostedProfileSelector,
   normalizeProfileConfigBinding,
   normalizeProfileAssetBinding,
   normalizeOsFamily,
@@ -19331,6 +19888,7 @@ export {
   compareAgentOperatingRulesVersions,
   cleanSessionPathInput,
   checkSessionRenderDrift,
+  buildSumiAgentsMd,
   buildStationProfileBlock,
   buildOpenCodeAgentsMd,
   buildCursorMdc,
@@ -19390,6 +19948,7 @@ export {
   LEGACY_CONFIGS_EXECUTABLE,
   LEGACY_CONFIGS_COMPAT_VERSION,
   KNOWN_CONFIGS,
+  InvalidExpectedVersionError,
   InstructionGraphValidationError,
   INSTRUCTION_GRAPH_PLAN_SCHEMA,
   INSTRUCTION_FALLBACKS,
@@ -19402,6 +19961,7 @@ export {
   GLOBAL_AGENT_RULES_STANDARD_CONTENT,
   DANGEROUS_OPERATION_GUARD_STANDARD_SLUG,
   DANGEROUS_OPERATION_GUARD_STANDARD_CONTENT,
+  ConfigVersionConflictError,
   ConfigNotFoundError,
   ConfigApplyError,
   CloudConfigStore,