@hasna/instructions 0.4.8 → 0.4.10

package/dist/cli/index.js

@@ -3220,37 +3220,123 @@ var init_config_agents = __esm(() => {
 });
 
 // src/lib/global-agent-rules-standard.ts
-async function ensureGlobalAgentRulesStandardConfig(store = resolveConfigStore()) {
-  const input = {
+import { createHash } from "crypto";
+function parseAgentOperatingRulesVersion(content) {
+  return content ? AGENT_OPERATING_RULES_SENTINEL_PATTERN.exec(content)?.[1] ?? null : null;
+}
+function compareAgentOperatingRulesVersions(left, right) {
+  const leftParts = left.split(".").map(Number);
+  const rightParts = right.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const diff = (leftParts[i] ?? 0) - (rightParts[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function payloadDate(content) {
+  const canonical = new RegExp(AGENT_OPERATING_RULES_HEADING_PATTERN.source, "m").exec(content)?.[1];
+  if (canonical)
+    return canonical;
+  const heading = /^#[^\S\n].*$/m.exec(content)?.[0];
+  return heading ? /\b([0-9]{4}-[0-9]{2}-[0-9]{2})\b/.exec(heading)?.[1] ?? null : null;
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function resolveAgentOperatingRulesPayload(storedContent) {
+  const stored = storedContent ?? "";
+  const storedVersion = parseAgentOperatingRulesVersion(stored);
+  const baselineOrder = storedVersion === null ? null : compareAgentOperatingRulesVersions(storedVersion, AGENT_OPERATING_RULES_VERSION);
+  const storedIsCurrent = baselineOrder !== null && (baselineOrder > 0 || baselineOrder === 0 && sha256(stored) === AGENT_OPERATING_RULES_PAYLOAD_SHA256);
+  const content = storedIsCurrent ? stored : GLOBAL_AGENT_RULES_STANDARD_CONTENT;
+  const origin = storedIsCurrent ? "stored-config" : "embedded-baseline";
+  const matchesEmbeddedBaseline = content === GLOBAL_AGENT_RULES_STANDARD_CONTENT;
+  const integrity = matchesEmbeddedBaseline ? "pinned-digest" : "unverified-self-declared";
+  const version = storedIsCurrent ? storedVersion : AGENT_OPERATING_RULES_VERSION;
+  const payloadSha256 = matchesEmbeddedBaseline ? AGENT_OPERATING_RULES_PAYLOAD_SHA256 : sha256(content);
+  const sourceSetVersion = matchesEmbeddedBaseline ? AGENT_OPERATING_RULES_SOURCE_SET_VERSION : payloadDate(content);
+  const upstreamPin = matchesEmbeddedBaseline ? {
+    upstreamRepository: AGENT_OPERATING_RULES_UPSTREAM.repository,
+    upstreamCommit: AGENT_OPERATING_RULES_UPSTREAM.commit,
+    upstreamPath: AGENT_OPERATING_RULES_UPSTREAM.path,
+    upstreamFileSha256: AGENT_OPERATING_RULES_UPSTREAM_FILE_SHA256
+  } : {};
+  const policyReference = content.includes(SCOPED_OPERATIONAL_CONTROL_POLICY_REFERENCE) ? { policyReference: SCOPED_OPERATIONAL_CONTROL_POLICY_REFERENCE } : {};
+  return {
+    content,
+    version,
+    origin,
+    matchesEmbeddedBaseline,
+    integrity,
+    provenance: {
+      source: AGENT_OPERATING_RULES_PROVENANCE.source,
+      payloadOrigin: origin,
+      payloadIntegrity: integrity,
+      ...upstreamPin,
+      upstreamExportId: AGENT_OPERATING_RULES_SOURCE_SET_ID,
+      upstreamSourceId: AGENT_OPERATING_RULES_SOURCE_ID,
+      selectedPayloadSha256: payloadSha256,
+      rulesVersion: version,
+      sourceSetVersion,
+      ...policyReference
+    },
+    metadata: {
+      sourceSet: AGENT_OPERATING_RULES_SOURCE_SET_ID,
+      role: AGENT_OPERATING_RULES_METADATA.role,
+      payloadOrigin: origin,
+      payloadIntegrity: integrity,
+      rulesVersion: version,
+      sourceSetVersion,
+      plan: GLOBAL_AGENT_RULES_STANDARD_SLUG,
+      contentSha256: payloadSha256,
+      selectedPayloadSha256: payloadSha256,
+      ...matchesEmbeddedBaseline ? { upstreamFileSha256: AGENT_OPERATING_RULES_UPSTREAM_FILE_SHA256 } : {},
+      upstreamExportId: AGENT_OPERATING_RULES_SOURCE_SET_ID,
+      upstreamSourceId: AGENT_OPERATING_RULES_SOURCE_ID,
+      sentinel: AGENT_OPERATING_RULES_METADATA.sentinel,
+      ...policyReference.policyReference ? { policyReferences: { incidentRecovery: SCOPED_OPERATIONAL_CONTROL_POLICY_REFERENCE } } : {}
+    }
+  };
+}
+function standardConfigInput(payload) {
+  return {
     name: "Global Agent Rules Standard",
     category: "rules",
     agent: "global",
     format: "markdown",
-    content: GLOBAL_AGENT_RULES_STANDARD_CONTENT,
+    content: payload.content,
     kind: "reference",
-    description: `Managed Hasna agent operating rules v${AGENT_OPERATING_RULES_VERSION}; accepted source ${AGENT_OPERATING_RULES_UPSTREAM.repository}@${AGENT_OPERATING_RULES_UPSTREAM.commit}:${AGENT_OPERATING_RULES_UPSTREAM.path}`,
+    description: payload.matchesEmbeddedBaseline ? `Managed Hasna agent operating rules v${payload.version}; accepted source ${AGENT_OPERATING_RULES_UPSTREAM.repository}@${AGENT_OPERATING_RULES_UPSTREAM.commit}:${AGENT_OPERATING_RULES_UPSTREAM.path}` : `Managed Hasna agent operating rules v${payload.version}; stored payload sha256 ${payload.metadata["contentSha256"]}`,
     tags: [
       "global-agent-rules",
       "system-prompt",
       "coding-agent-rules",
       "agent-operating-rules",
-      `rules-version:${AGENT_OPERATING_RULES_VERSION}`,
-      `source-commit:${AGENT_OPERATING_RULES_UPSTREAM.commit}`
+      `rules-version:${payload.version}`,
+      ...payload.matchesEmbeddedBaseline ? [`source-commit:${AGENT_OPERATING_RULES_UPSTREAM.commit}`] : []
     ]
   };
+}
+async function ensureGlobalAgentRulesStandardConfig(store = resolveConfigStore()) {
+  let existing;
   try {
-    const existing = await store.getConfig(GLOBAL_AGENT_RULES_STANDARD_SLUG);
-    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;
+    existing = await store.getConfig(GLOBAL_AGENT_RULES_STANDARD_SLUG);
   } catch {
-    return await store.createConfig(input);
+    return await store.createConfig(standardConfigInput(resolveAgentOperatingRulesPayload(null)));
+  }
+  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)) {
+    return await store.updateConfig(existing.id, input);
   }
+  return existing;
 }
-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_VERSION = "1.1.6", AGENT_OPERATING_RULES_SOURCE_SET_VERSION = "2026-07-23", AGENT_OPERATING_RULES_SENTINEL = "<!-- hasna:agent-operating-rules v=1.1.6 -->", AGENT_OPERATING_RULES_PAYLOAD_SHA256 = "8b236086b82e94490516e0b00dffa03fb5f6841b68d95f80fc3e3c8fb7087420", 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, NO_BRITTLE_HARDCODING_RULE = "Do not hardcode brittle values, paths, provider names, config, business logic, environment-specific IDs, or one-off mappings when a source-of-truth, schema/config-driven, package-owned, reusable, or cleaner abstraction exists. This is especially strict in medium and large applications. Explicit constants, fixtures, tests, and temporary compatibility shims are allowed only when scoped, named, and justified.", GLOBAL_AGENT_RULES_STANDARD_CONTENT;
+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.6", AGENT_OPERATING_RULES_SOURCE_SET_VERSION = "2026-07-23", AGENT_OPERATING_RULES_SENTINEL = "<!-- hasna:agent-operating-rules v=1.1.6 -->", 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 = "8b236086b82e94490516e0b00dffa03fb5f6841b68d95f80fc3e3c8fb7087420", 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, NO_BRITTLE_HARDCODING_RULE = "Do not hardcode brittle values, paths, provider names, config, business logic, environment-specific IDs, or one-off mappings when a source-of-truth, schema/config-driven, package-owned, reusable, or cleaner abstraction exists. This is especially strict in medium and large applications. Explicit constants, fixtures, tests, and temporary compatibility shims are allowed only when scoped, named, and justified.", GLOBAL_AGENT_RULES_STANDARD_CONTENT;
 var init_global_agent_rules_standard = __esm(() => {
   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})\)/;
   AGENT_OPERATING_RULES_UPSTREAM = {
     repository: "hasnaxyz/iapp-identities",
     commit: "48168c549cc2945053a4498a9a2b11888419bc94",
@@ -3279,7 +3365,7 @@ var init_global_agent_rules_standard = __esm(() => {
   };
   AGENT_OPERATING_RULES_METADATA = {
     sourceSet: AGENT_OPERATING_RULES_SOURCE_SET_ID,
-    role: "agent-operating-rules",
+    role: AGENT_OPERATING_RULES_ROLE,
     rulesVersion: AGENT_OPERATING_RULES_VERSION,
     sourceSetVersion: AGENT_OPERATING_RULES_SOURCE_SET_VERSION,
     plan: GLOBAL_AGENT_RULES_STANDARD_SLUG,
@@ -3288,7 +3374,7 @@ var init_global_agent_rules_standard = __esm(() => {
     upstreamFileSha256: AGENT_OPERATING_RULES_UPSTREAM_FILE_SHA256,
     upstreamExportId: AGENT_OPERATING_RULES_SOURCE_SET_ID,
     upstreamSourceId: AGENT_OPERATING_RULES_SOURCE_ID,
-    sentinel: "hasna:agent-operating-rules",
+    sentinel: AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY,
     policyReferences: {
       incidentRecovery: SCOPED_OPERATIONAL_CONTROL_POLICY_REFERENCE
     }
@@ -7480,8 +7566,11 @@ var init_redact = __esm(() => {
 });
 
 // src/lib/session-render-contract.ts
-var CODEWITH_NATIVE_IMPORTS_ENV = "HASNA_CONFIGS_CODEWITH_NATIVE_IMPORTS", SESSION_RENDER_MANAGED_MARKER = "Managed by @hasna/configs session render", SESSION_RENDER_SCHEMA = "hasna.configs.session-render/v1", SESSION_INSTRUCTION_LAYERS;
+var CODEWITH_NATIVE_IMPORTS_ENV = "HASNA_CONFIGS_CODEWITH_NATIVE_IMPORTS", SESSION_RENDER_MANAGED_MARKER = "Managed by @hasna/configs session render", SESSION_RENDER_SCHEMA = "hasna.configs.session-render/v1", SESSION_RENDER_MANAGED_NAMESPACE = ".hasna", SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR, SESSION_RENDER_MANIFEST_RELATIVE_PATH, SESSION_RENDER_SNAPSHOT_RELATIVE_DIR, SESSION_INSTRUCTION_LAYERS;
 var init_session_render_contract = __esm(() => {
+  SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR = `${SESSION_RENDER_MANAGED_NAMESPACE}/instructions`;
+  SESSION_RENDER_MANIFEST_RELATIVE_PATH = `${SESSION_RENDER_MANAGED_NAMESPACE}/session-render-manifest.json`;
+  SESSION_RENDER_SNAPSHOT_RELATIVE_DIR = `${SESSION_RENDER_MANAGED_NAMESPACE}/session-render-snapshots`;
   SESSION_INSTRUCTION_LAYERS = [
     "global",
     "tool",
@@ -7498,7 +7587,7 @@ var init_session_render_contract = __esm(() => {
 });
 
 // src/lib/project-context.ts
-import { createHash, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID6 } from "crypto";
 import { execFileSync } from "child_process";
 import { dlopen, FFIType } from "bun:ffi";
 import {
@@ -7520,7 +7609,7 @@ import {
 import { basename, dirname, isAbsolute, join as join4, parse, relative, resolve } from "path";
 function computeProjectContextSourceHash(value) {
   const normalized = removeHashForFingerprint(value);
-  return `sha256:${sha256(stableStringify(normalized))}`;
+  return `sha256:${sha2562(stableStringify(normalized))}`;
 }
 function parseProjectContextBundle(input) {
   let encoded;
@@ -7690,7 +7779,7 @@ function composeProjectContextSessionRender(input) {
   const files = input.files.map((file) => file === index ? {
     ...file,
     content,
-    sha256: sha256(content),
+    sha256: sha2562(content),
     sourceIds: [...new Set([...file.sourceIds, "project-context-bundle"])]
   } : file);
   if (observedHashes.some((observed) => currentFileHash(observed.path, workspaceRoot) !== observed.sha256)) {
@@ -7891,7 +7980,7 @@ function assertRenderedOutputsStable(plan, cacheContent, sessionOutput) {
     sessionOutput
   ];
   for (const output of outputs) {
-    if (currentFileHash(output.path, plan.workspace_root) !== sha256(output.content)) {
+    if (currentFileHash(output.path, plan.workspace_root) !== sha2562(output.content)) {
       throw new ProjectContextHashRace(`managed path changed before manifest commit: ${relativePosix(plan.workspace_root, output.path)}`);
     }
   }
@@ -8111,7 +8200,7 @@ function findLegacyCodewithWorkspaceSection(workspaceRoot, runtime, content, bun
     return null;
   const files = Array.isArray(manifest["files"]) ? manifest["files"] : [];
   const codewith = files.find((file) => isRecord(file) && file["relativePath"] === "CODEWITH.md");
-  if (!isRecord(codewith) || codewith["sha256"] !== sha256(content)) {
+  if (!isRecord(codewith) || codewith["sha256"] !== sha2562(content)) {
     throw new ProjectContextError("MANAGED_BLOCK_CONFLICT", "legacy /dev/fd session manifest does not match CODEWITH.md");
   }
   const section = /^## Workspace\r?\n/gm.exec(content);
@@ -8181,14 +8270,14 @@ function buildManifest(plan, now3) {
       path: plan.fragment_path,
       relativePath: PROJECT_CONTEXT_FRAGMENT_PATH,
       role: "fragment",
-      sha256: sha256(plan.fragment),
+      sha256: sha2562(plan.fragment),
       sourceIds: ["project-context-bundle"]
     },
     {
       path: plan.target_path,
       relativePath: plan.target_relative_path,
       role: "index",
-      sha256: sha256(plan.target_content),
+      sha256: sha2562(plan.target_content),
       sourceIds: ["project-context-bundle"]
     }
   ];
@@ -8265,7 +8354,7 @@ function buildSessionCompatibilityManifest(plan, now3) {
     path: plan.target_path,
     relativePath: targetRelativePath,
     role: "index",
-    sha256: sha256(plan.target_content),
+    sha256: sha2562(plan.target_content),
     sourceIds: [...new Set([...previousSourceIds ?? [], "project-context-bundle"])]
   };
   const targetOwner = isRecord(existing["targetOwner"]) ? existing["targetOwner"] : {};
@@ -8293,7 +8382,7 @@ function buildSessionCompatibilityManifest(plan, now3) {
     blockers: [],
     generatedAt: now3.toISOString(),
     env: sanitizeLegacyEnvironment(existing["env"]),
-    sourceHash: sha256(stableStringify({ previous: typeof existing["sourceHash"] === "string" ? existing["sourceHash"] : null, projectContext: plan.bundle.hash })),
+    sourceHash: sha2562(stableStringify({ previous: typeof existing["sourceHash"] === "string" ? existing["sourceHash"] : null, projectContext: plan.bundle.hash })),
     sources,
     skippedSources: sanitizeLegacySkippedSources(existing["skippedSources"]),
     files: [...files.filter((file) => file["relativePath"] !== targetRelativePath), updatedTarget],
@@ -8496,7 +8585,7 @@ function projectContextManifestSource(cachePath, runtime, bundle) {
     nonOverridable: true,
     replacementScope: "project-context",
     rules: [],
-    renderedPayloadSha256: sha256(JSON.stringify(bundle)),
+    renderedPayloadSha256: sha2562(JSON.stringify(bundle)),
     provenance: {
       schema: PROJECT_CONTEXT_SCHEMA,
       projectId: bundle.project.id,
@@ -8618,7 +8707,7 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
   let fd = null;
   let preserveTemp = false;
   let directoryChanged = false;
-  const desiredHash = sha256(content);
+  const desiredHash = sha2562(content);
   try {
     fd = anchoredOpenExclusive(directory, tempName, previousMode);
     writeFileSync(fd, content, { encoding: "utf8" });
@@ -8627,7 +8716,7 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
     fd = null;
     beforeInstall?.(tempPath);
     assertManagedDirectoryStable(dir, workspaceRoot, directory.identity);
-    if (anchoredFileHash(directory, tempName) !== desiredHash) {
+    if (anchoredPreparedObservation(directory, tempName, path, "before installation").hash !== desiredHash) {
       throw new ProjectContextHashRace(`prepared bytes changed before installation: ${relativePosix(workspaceRoot, path)}`);
     }
     if (expectedHash === undefined) {
@@ -8636,8 +8725,8 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
       }
       directoryChanged = true;
     } else if (expectedHash === null) {
-      const prepared = anchoredFileObservation(directory, tempName);
-      if (!prepared || anchoredFileObservation(directory, targetName) !== null) {
+      const prepared = anchoredPreparedObservation(directory, tempName, path, "before creation");
+      if (anchoredFileObservation(directory, targetName) !== null) {
         throw new ProjectContextHashRace(`managed path appeared before creation: ${relativePosix(workspaceRoot, path)}`);
       }
       if (!directory.ops.linkat(directory.fd, tempName, directory.fd, targetName)) {
@@ -8645,7 +8734,8 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
       }
       directoryChanged = true;
       const installed = anchoredFileObservation(directory, targetName);
-      if (!installed || installed.dev !== prepared.dev || installed.ino !== prepared.ino || anchoredFileHash(directory, tempName) !== desiredHash || installed.hash !== desiredHash) {
+      const stagedHash = anchoredFileHash(directory, tempName);
+      if (!installed || installed.dev !== prepared.dev || installed.ino !== prepared.ino || stagedHash !== desiredHash || installed.hash !== desiredHash) {
         directory.ops.unlinkat(directory.fd, tempName);
         preserveTemp = true;
         throw new ProjectContextHashRace(`prepared bytes changed during creation: ${relativePosix(workspaceRoot, path)}`);
@@ -8662,7 +8752,7 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
       if (anchoredFileHash(directory, targetName) !== expectedHash) {
         throw new ProjectContextHashRace(`managed path changed before atomic replacement: ${relativePosix(workspaceRoot, path)}`);
       }
-      if (anchoredFileHash(directory, tempName) !== desiredHash) {
+      if (anchoredPreparedObservation(directory, tempName, path, "before atomic replacement").hash !== desiredHash) {
         throw new ProjectContextHashRace(`prepared bytes changed before atomic replacement: ${relativePosix(workspaceRoot, path)}`);
       }
       atomicExchangeEntries(directory.fd, tempName, targetName);
@@ -8728,7 +8818,7 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
   }
 }
 function atomicWritePortable(path, content, workspaceRoot, defaultMode, expectedHash, beforeInstall, maxObservedBytes, allowReplacement = false) {
-  const desiredHash = sha256(content);
+  const desiredHash = sha2562(content);
   const currentHash = portableFileHash(path, workspaceRoot, maxObservedBytes);
   if (expectedHash === undefined && currentHash === desiredHash)
     return;
@@ -8759,7 +8849,7 @@ function atomicWritePortable(path, content, workspaceRoot, defaultMode, expected
     assertManagedDirectoryStable(dir, workspaceRoot, directoryIdentity);
     assertNoSymlinkSegments(workspaceRoot, tempPath);
     assertNoSymlinkSegments(workspaceRoot, path);
-    if (portableFileHash(tempPath, workspaceRoot, maxObservedBytes) !== desiredHash || portableFileHash(path, workspaceRoot, maxObservedBytes) !== null) {
+    if (portablePreparedHash(tempPath, path, workspaceRoot, maxObservedBytes, "before portable creation") !== desiredHash || portableFileHash(path, workspaceRoot, maxObservedBytes) !== null) {
       throw new ProjectContextHashRace(`managed path changed before portable creation: ${relativePosix(workspaceRoot, path)}`);
     }
     const prepared = lstatSync(tempPath);
@@ -8802,7 +8892,7 @@ function atomicWritePortableReplacement(path, content, workspaceRoot, expectedHa
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
   const tempPath = join4(dir, `.project-context-${randomUUID6()}.tmp`);
-  const desiredHash = sha256(content);
+  const desiredHash = sha2562(content);
   let fd = null;
   let tempIdentity = null;
   try {
@@ -8817,7 +8907,7 @@ function atomicWritePortableReplacement(path, content, workspaceRoot, expectedHa
     assertManagedDirectoryStable(dir, workspaceRoot, directoryIdentity);
     assertNoSymlinkSegments(workspaceRoot, tempPath);
     assertNoSymlinkSegments(workspaceRoot, path);
-    if (portableFileHash(path, workspaceRoot, maxObservedBytes) !== expectedHash || portableFileHash(tempPath, workspaceRoot, maxObservedBytes) !== desiredHash) {
+    if (portableFileHash(path, workspaceRoot, maxObservedBytes) !== expectedHash || portablePreparedHash(tempPath, path, workspaceRoot, maxObservedBytes, "before portable replacement") !== desiredHash) {
       throw new ProjectContextHashRace(`managed path changed before portable replacement: ${relativePosix(workspaceRoot, path)}`);
     }
     renameSync(tempPath, path);
@@ -8841,6 +8931,20 @@ function atomicWritePortableReplacement(path, content, workspaceRoot, expectedHa
     throw error;
   }
 }
+function portablePreparedHash(tempPath, path, workspaceRoot, maxObservedBytes, stage) {
+  const unreadable = (cause) => new ProjectContextError("PROJECT_CONTEXT_PREPARED_FILE_UNREADABLE", `the prepared managed file could not be read back ${stage}: ${relativePosix(workspaceRoot, path)}`, { staged_path: tempPath, stage, ...cause === undefined ? {} : { cause } });
+  let hash;
+  try {
+    hash = portableFileHash(tempPath, workspaceRoot, maxObservedBytes);
+  } catch (error) {
+    if (error instanceof ProjectContextError || error instanceof ProjectContextHashRace)
+      throw error;
+    throw unreadable(error.message);
+  }
+  if (hash === null)
+    throw unreadable();
+  return hash;
+}
 function portableFileHash(path, workspaceRoot, maxObservedBytes) {
   if (maxObservedBytes === undefined)
     return currentFileHash(path, workspaceRoot);
@@ -8853,10 +8957,10 @@ function portableFileHash(path, workspaceRoot, maxObservedBytes) {
   if (maxObservedBytes !== null && stat.size > maxObservedBytes) {
     throw new ProjectContextHashRace(`managed output exceeds the safe read limit: ${relativePosix(workspaceRoot, path)}`);
   }
-  return createHash("sha256").update(readFileSync(path)).digest("hex");
+  return createHash2("sha256").update(readFileSync(path)).digest("hex");
 }
 function writeProjectContextCoordinatedFile(input) {
-  atomicWriteFile(resolve(input.path), input.content, assertSafeWorkspaceRoot(input.workspace_root), input.default_mode ?? 420, input.expected_hash, undefined, false, undefined, input.force_portable_file_ops ?? false, input.max_observed_bytes, input.allow_portable_replacement ?? false);
+  atomicWriteFile(resolve(input.path), input.content, assertSafeWorkspaceRoot(input.workspace_root), input.default_mode ?? 420, input.expected_hash, undefined, false, input.test_hooks?.before_install, input.force_portable_file_ops ?? false, input.max_observed_bytes, input.allow_portable_replacement ?? false);
 }
 function removeProjectContextCoordinatedFile(input) {
   const workspaceRoot = assertSafeWorkspaceRoot(input.workspace_root);
@@ -9000,15 +9104,43 @@ function openAnchoredDirectory(path, workspaceRoot, providedOps, maxObservedByte
   }
 }
 function anchoredOpenExclusive(directory, name, mode) {
-  const fd = directory.ops.openat(directory.fd, name, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, mode);
-  if (fd < 0)
+  const requestedMode = mode & 4095;
+  let fd;
+  try {
+    fd = openSync(join4(directory.path, name), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, requestedMode);
+  } catch {
     throw new ProjectContextHashRace(`could not create prepared managed file in ${relativePosix(directory.workspaceRoot, directory.path)}`);
-  const opened = fstatSync(fd);
-  if (!opened.isFile()) {
+  }
+  try {
+    const opened = fstatSync(fd);
+    if (!opened.isFile()) {
+      throw new ProjectContextHashRace("prepared managed output is not a regular file");
+    }
+    if (!isPreparedManagedFileModeUsable(requestedMode, opened.mode)) {
+      throw new ProjectContextError("PROJECT_CONTEXT_PREPARED_FILE_MODE_REJECTED", `the platform created the prepared managed file with an unusable mode in ${relativePosix(directory.workspaceRoot, directory.path)}`, { requested_mode: modeLiteral(requestedMode), observed_mode: modeLiteral(opened.mode) });
+    }
+    assertManagedDirectoryStable(directory.path, directory.workspaceRoot, directory.identity);
+    const anchored = anchoredFileObservation(directory, name);
+    if (!anchored || anchored.dev !== opened.dev || anchored.ino !== opened.ino) {
+      throw new ProjectContextHashRace(`prepared managed file is not the one anchored in ${relativePosix(directory.workspaceRoot, directory.path)}`);
+    }
+    return fd;
+  } catch (error) {
     closeSync(fd);
-    throw new ProjectContextHashRace("prepared managed output is not a regular file");
+    throw error;
   }
-  return fd;
+}
+function modeLiteral(mode) {
+  return `0o${(mode & 4095).toString(8).padStart(3, "0")}`;
+}
+function isPreparedManagedFileModeUsable(requestedMode, observedMode) {
+  const requested = requestedMode & 4095;
+  const observed = observedMode & 4095;
+  if ((observed & ~requested) !== 0)
+    return false;
+  if ((requested & 256) !== 0 && (observed & 256) === 0)
+    return false;
+  return true;
 }
 function anchoredFileObservation(directory, name) {
   const fd = directory.ops.openat(directory.fd, name, constants.O_RDONLY | constants.O_NOFOLLOW, 0);
@@ -9026,7 +9158,7 @@ function anchoredFileObservation(directory, name) {
     return {
       dev: stat.dev,
       ino: stat.ino,
-      hash: createHash("sha256").update(readFileSync(fd)).digest("hex"),
+      hash: createHash2("sha256").update(readFileSync(fd)).digest("hex"),
       mode: stat.mode & 511
     };
   } finally {
@@ -9036,6 +9168,13 @@ function anchoredFileObservation(directory, name) {
 function anchoredFileHash(directory, name) {
   return anchoredFileObservation(directory, name)?.hash ?? null;
 }
+function anchoredPreparedObservation(directory, name, path, stage) {
+  const observed = anchoredFileObservation(directory, name);
+  if (!observed) {
+    throw new ProjectContextError("PROJECT_CONTEXT_PREPARED_FILE_UNREADABLE", `the prepared managed file could not be read back ${stage}: ${relativePosix(directory.workspaceRoot, path)}`, { staged_name: name, stage });
+  }
+  return observed;
+}
 function captureManagedDirectoryIdentity(path, workspaceRoot) {
   assertNoSymlinkSegments(workspaceRoot, join4(path, ".project-context-directory-guard"));
   let stat;
@@ -9204,7 +9343,7 @@ function acquireWorkspaceLock(workspaceRoot, lockPath, afterOpen, beforeStaleRem
       process_start_id: processStartIdentityLookup(process.pid)
     })}
 `;
-    openedContentHash = sha256(content);
+    openedContentHash = sha2562(content);
     writeFileSync(fd, content);
     fsyncSync(fd);
     try {
@@ -9255,7 +9394,7 @@ function removeOwnedLockByInode(lockPath, identity, expectedHash) {
     const current = lstatSync(lockPath);
     if (current.isSymbolicLink() || current.dev !== identity.dev || current.ino !== identity.ino)
       return;
-    if (expectedHash !== undefined && sha256(readFileSync(lockPath, "utf8")) !== expectedHash)
+    if (expectedHash !== undefined && sha2562(readFileSync(lockPath, "utf8")) !== expectedHash)
       return;
     rmSync2(lockPath);
     fsyncDirectory(resolve(lockPath, ".."));
@@ -9272,7 +9411,7 @@ function observeStaleWorkspaceLock(lockPath, workspaceRoot, processStartIdentity
   } catch {
     return null;
   }
-  const contentHash = sha256(content);
+  const contentHash = sha2562(content);
   if (currentFileHash(lockPath, workspaceRoot) !== contentHash)
     return null;
   let pid = null;
@@ -9434,7 +9573,7 @@ function releaseWorkspaceLock(lockPath, lock, workspaceRoot) {
       created_at: new Date().toISOString()
     })}
 `;
-    releaseHash = sha256(releaseContent);
+    releaseHash = sha2562(releaseContent);
     writeFileSync(releaseFd, releaseContent);
     fsyncSync(releaseFd);
     closeSync(releaseFd);
@@ -9673,7 +9812,7 @@ function currentFileHash(path, workspaceRoot) {
     return null;
   const relativePath = relativePosix(workspaceRoot, path);
   const maxBytes = relativePath === ".hasna/session-render-manifest.json" || relativePath === ".codewith/.hasna/session-render-manifest.json" ? SESSION_COMPATIBILITY_MANIFEST_MAX_BYTES : 256 * 1024;
-  return sha256(readUtf8RegularFile(path, workspaceRoot, maxBytes));
+  return sha2562(readUtf8RegularFile(path, workspaceRoot, maxBytes));
 }
 function hashesStillMatch(expected, workspaceRoot) {
   for (const [path, hash] of expected) {
@@ -9842,8 +9981,8 @@ function removeHashForFingerprint(value) {
   }
   return copy;
 }
-function sha256(content) {
-  return createHash("sha256").update(content).digest("hex");
+function sha2562(content) {
+  return createHash2("sha256").update(content).digest("hex");
 }
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -10110,7 +10249,7 @@ function applyTransform(source, output, context = {}) {
 var init_transforms = () => {};
 
 // src/lib/session-render.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync2, realpathSync, statSync as statSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { basename as basename3, dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join5, parse as parse2, posix, relative as relative2, resolve as resolve2 } from "path";
@@ -10130,11 +10269,11 @@ function ensureTrailingNewline3(content) {
 `) ? content : `${content}
 `;
 }
-function sha2562(content) {
-  return createHash2("sha256").update(content).digest("hex");
+function sha2563(content) {
+  return createHash3("sha256").update(content).digest("hex");
 }
 function fingerprint(value) {
-  return sha2562(JSON.stringify(value));
+  return sha2563(JSON.stringify(value));
 }
 function canonicalFingerprintValue(value) {
   if (Array.isArray(value))
@@ -10200,18 +10339,59 @@ function makeFile(targetHome, relativePath, role, content, sourceIds) {
     relativePath: safeRelativePath,
     role,
     content: normalizedContent,
-    sha256: sha2562(normalizedContent),
+    sha256: sha2563(normalizedContent),
     sourceIds
   };
 }
+function claimsAgentOperatingRulesPolicy(source, content) {
+  if (!AGENT_OPERATING_RULES_SENTINEL_PATTERN.test(content))
+    return false;
+  if (source.nonOverridable === true)
+    return true;
+  if (source.id === GLOBAL_AGENT_RULES_STANDARD_SLUG || source.id === AGENT_OPERATING_RULES_SOURCE_ID)
+    return true;
+  if (source.metadata?.["role"] === AGENT_OPERATING_RULES_ROLE)
+    return true;
+  return AGENT_OPERATING_RULES_HEADING_PATTERN.test(content.trimStart());
+}
+function applyAgentOperatingRulesFloor(source, content) {
+  const unchanged = {
+    content,
+    provenance: source.provenance ?? null,
+    metadata: source.metadata ?? null
+  };
+  if (!claimsAgentOperatingRulesPolicy(source, content))
+    return unchanged;
+  const payload = resolveAgentOperatingRulesPayload(content);
+  if (payload.content === content) {
+    return {
+      content,
+      provenance: { ...source.provenance ?? {}, payloadIntegrity: payload.integrity },
+      metadata: { ...source.metadata ?? {}, payloadIntegrity: payload.integrity }
+    };
+  }
+  const floored = {
+    payloadFloorApplied: true,
+    flooredFromRulesVersion: parseAgentOperatingRulesVersion(content),
+    flooredFromPayloadSha256: sha2563(content)
+  };
+  return {
+    content: payload.content,
+    provenance: { ...source.provenance ?? {}, ...payload.provenance, ...floored },
+    metadata: { ...source.metadata ?? {}, ...payload.metadata, ...floored }
+  };
+}
 function normalizeSources(sources, tool, allowEmptySources) {
   const normalized = sources.map((source, index) => {
     if (!source.id.trim())
       throw new Error("Session instruction source id is required.");
-    const content = filterProviderOnlyBlocks(source.content ?? "", tool);
+    const floored = applyAgentOperatingRulesFloor(source, source.content ?? "");
+    const content = filterProviderOnlyBlocks(floored.content, tool);
     const normalized2 = {
       ...source,
       content,
+      provenance: floored.provenance,
+      metadata: floored.metadata,
       normalizedId: slug(source.id),
       resolvedLabel: source.label ?? source.id,
       resolvedLayer: source.layer === undefined ? "agent" : normalizeSessionInstructionLayer(source.layer),
@@ -10234,30 +10414,36 @@ function deduplicateSemanticPolicySources(sources) {
   const selected = [];
   const policySources = new Map;
   for (const source of sources) {
-    const sentinel = source.content.match(/<!--\s*hasna:agent-operating-rules\s+v=([0-9]+\.[0-9]+\.[0-9]+)\s*-->/i);
+    const sentinel = source.content.match(AGENT_OPERATING_RULES_SENTINEL_PATTERN);
     if (!sentinel) {
       selected.push(source);
       continue;
     }
-    const key = `hasna:agent-operating-rules/v${sentinel[1]}`;
+    const version = sentinel[1];
+    const key = AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY;
     const normalizedContent = source.content.replace(/\r\n/g, `
 `).trim();
     const existing = policySources.get(key);
     if (!existing) {
-      policySources.set(key, { index: selected.length, normalizedContent });
+      policySources.set(key, { index: selected.length, version, normalizedContent });
       selected.push(source);
       continue;
     }
-    if (existing.normalizedContent !== normalizedContent) {
-      throw new Error(`Conflicting semantic policy sources declare ${key} with different content.`);
+    const versionOrder = compareAgentOperatingRulesVersions(version, existing.version);
+    if (versionOrder === 0 && existing.normalizedContent !== normalizedContent) {
+      throw new Error(`Conflicting semantic policy sources declare ${key}/v${version} with different content.`);
     }
     const current = selected[existing.index];
-    if (semanticPolicySourcePriority(source) <= semanticPolicySourcePriority(current))
+    const priorityOrder = semanticPolicySourcePriority(source) - semanticPolicySourcePriority(current);
+    if (priorityOrder < 0)
+      continue;
+    if (priorityOrder === 0 && versionOrder <= 0)
       continue;
     selected[existing.index] = {
       ...source,
       resolvedOrder: current.resolvedOrder
     };
+    policySources.set(key, { index: existing.index, version, normalizedContent });
   }
   return selected;
 }
@@ -10267,7 +10453,7 @@ function semanticPolicySourcePriority(source) {
     priority += 4;
   if (source.id === GLOBAL_AGENT_RULES_STANDARD_SLUG)
     priority += 2;
-  if (source.metadata?.["role"] === "agent-operating-rules")
+  if (source.metadata?.["role"] === AGENT_OPERATING_RULES_ROLE)
     priority += 1;
   return priority;
 }
@@ -10756,7 +10942,7 @@ function planSessionRender(input) {
           globs: rule.globs ?? [],
           hash: rule.hash ?? null
         })),
-        renderedPayloadSha256: sha2562(source.content),
+        renderedPayloadSha256: sha2563(source.content),
         provenance: source.provenance ?? null,
         metadata: source.metadata ?? null
       })),
@@ -10774,8 +10960,8 @@ function planSessionRender(input) {
     ...input.providerConfig ? {
       providerConfig: {
         sourceId: input.providerConfig.sourceId,
-        selectedPayloadSha256: sha2562(input.providerConfig.content),
-        renderedPayloadSha256: files.find((file) => file.relativePath === adapter.configFile)?.sha256 ?? sha2562(input.providerConfig.content),
+        selectedPayloadSha256: sha2563(input.providerConfig.content),
+        renderedPayloadSha256: files.find((file) => file.relativePath === adapter.configFile)?.sha256 ?? sha2563(input.providerConfig.content),
         selected: !existsSync5(joinTarget(targetHome, adapter.configFile))
       }
     } : {},
@@ -10819,15 +11005,16 @@ function sourceFromFilePath(path, content, order = 0) {
 }
 function sourceFromConfig(config, order = 0, layer) {
   const isAgentOperatingRules = config.slug === GLOBAL_AGENT_RULES_STANDARD_SLUG;
+  const rules = isAgentOperatingRules ? resolveAgentOperatingRulesPayload(config.content) : null;
   return {
     id: config.slug,
     label: config.name,
-    content: isAgentOperatingRules ? GLOBAL_AGENT_RULES_STANDARD_CONTENT : config.content,
+    content: rules ? rules.content : config.content,
     layer: layer ?? (config.agent === "global" ? "global" : "agent"),
     order,
     path: config.target_path ?? undefined,
-    provenance: isAgentOperatingRules ? {
-      ...AGENT_OPERATING_RULES_PROVENANCE,
+    provenance: rules ? {
+      ...rules.provenance,
       configSlug: config.slug,
       configAgent: config.agent
     } : {
@@ -10835,7 +11022,7 @@ function sourceFromConfig(config, order = 0, layer) {
       configSlug: config.slug,
       configAgent: config.agent
     },
-    metadata: isAgentOperatingRules ? { ...AGENT_OPERATING_RULES_METADATA } : null,
+    metadata: rules ? { ...rules.metadata } : null,
     nonOverridable: isAgentOperatingRules
   };
 }
@@ -11121,7 +11308,7 @@ function asStringArray(value) {
     return [];
   return value.filter((item) => typeof item === "string");
 }
-var RAW_STORE_ROOT_ENV = "HASNA_CONFIGS_HOME", ANTIGRAVITY_RULE_FILE_CHAR_LIMIT = 12000, SESSION_RENDERER_OWNER_ID = "instructions-session-renderer", SESSION_RENDER_TOOLS, SESSION_RENDER_PROFILE_ENTRYPOINTS, SESSION_RENDER_OWNED_CONFIG_TARGETS, CODEWITH_FLATTENED_ADAPTER, CODEWITH_NATIVE_ADAPTER, SESSION_TOOL_ADAPTERS, SESSION_LAYER_RANK;
+var RAW_STORE_ROOT_ENV = "HASNA_CONFIGS_HOME", ANTIGRAVITY_RULE_FILE_CHAR_LIMIT = 12000, SESSION_RENDERER_OWNER_ID = "instructions-session-renderer", SESSION_RENDER_TOOLS, SESSION_RENDER_PROFILE_ENTRYPOINTS, SESSION_RENDER_OWNED_CONFIG_TARGETS, CODEWITH_FLATTENED_ADAPTER, CODEWITH_NATIVE_ADAPTER, SESSION_TOOL_ADAPTERS, SESSION_RENDER_MANAGED_DIRS, SESSION_RENDER_SHARED_MANAGED_DIRS, SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS, SESSION_LAYER_RANK;
 var init_session_render = __esm(() => {
   init_global_agent_rules_standard();
   init_project_context();
@@ -11154,7 +11341,7 @@ var init_session_render = __esm(() => {
     tool: "codewith",
     mode: "flattened-markdown",
     indexFile: "CODEWITH.md",
-    managedDir: ".hasna/instructions",
+    managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
     envVar: "CODEWITH_HOME",
     nativeImports: false,
     description: "Codewith CODEWITH.md flattened until native @ imports are implemented in Codewith."
@@ -11163,7 +11350,7 @@ var init_session_render = __esm(() => {
     tool: "codewith",
     mode: "native-imports",
     indexFile: "CODEWITH.md",
-    managedDir: ".hasna/instructions",
+    managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
     envVar: "CODEWITH_HOME",
     nativeImports: true,
     description: "Codewith CODEWITH.md with gated @ imports into managed fragments."
@@ -11173,7 +11360,7 @@ var init_session_render = __esm(() => {
       tool: "claude",
       mode: "native-imports",
       indexFile: "CLAUDE.md",
-      managedDir: ".hasna/instructions",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
       envVar: "CLAUDE_CONFIG_DIR",
       nativeImports: true,
       description: "Claude Code CLAUDE.md with @ imports into managed fragments."
@@ -11182,7 +11369,7 @@ var init_session_render = __esm(() => {
       tool: "codex",
       mode: "flattened-markdown",
       indexFile: "AGENTS.md",
-      managedDir: ".hasna/instructions",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
       envVar: "CODEX_HOME",
       nativeImports: false,
       description: "Codex AGENTS.md flattened instruction file."
@@ -11199,7 +11386,7 @@ var init_session_render = __esm(() => {
       mode: "opencode-instructions",
       indexFile: "AGENTS.md",
       configFile: "opencode.json",
-      managedDir: ".hasna/instructions",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
       envVar: "OPENCODE_CONFIG_DIR",
       nativeImports: false,
       description: "OpenCode AGENTS.md plus opencode.json instructions pointing at managed fragments."
@@ -11208,7 +11395,7 @@ var init_session_render = __esm(() => {
       tool: "aicopilot",
       mode: "flattened-markdown",
       indexFile: "AICOPILOT.md",
-      managedDir: ".hasna/instructions",
+      managedDir: SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR,
       envVar: "AICOPILOT_CONFIG_DIR",
       nativeImports: false,
       description: "AI Copilot AICOPILOT.md flattened instruction file."
@@ -11231,6 +11418,19 @@ var init_session_render = __esm(() => {
     },
     codewith: CODEWITH_FLATTENED_ADAPTER
   };
+  SESSION_RENDER_MANAGED_DIRS = [
+    ...new Set([
+      CODEWITH_FLATTENED_ADAPTER,
+      CODEWITH_NATIVE_ADAPTER,
+      ...Object.values(SESSION_TOOL_ADAPTERS)
+    ].map((adapter) => adapter.managedDir))
+  ];
+  SESSION_RENDER_SHARED_MANAGED_DIRS = [".cursor/rules"];
+  SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS = [
+    ...SESSION_RENDER_MANAGED_DIRS.filter((dir) => !SESSION_RENDER_SHARED_MANAGED_DIRS.includes(dir)),
+    SESSION_RENDER_MANIFEST_RELATIVE_PATH,
+    SESSION_RENDER_SNAPSHOT_RELATIVE_DIR
+  ];
   SESSION_LAYER_RANK = {
     global: 10,
     tool: 20,
@@ -11246,6 +11446,80 @@ var init_session_render = __esm(() => {
   };
 });
 
+// src/lib/session-render-ownership.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { dirname as dirname3, join as join6, parse as parse3, relative as relative3, sep } from "path";
+function toSegments(absolutePath2) {
+  return absolutePath2.replaceAll("\\", "/").split("/").filter(Boolean);
+}
+function pathIsSessionRenderManagedDir(absolutePath2) {
+  const segments = toSegments(absolutePath2);
+  return MANAGED_PATH_SEGMENTS.some((managed) => {
+    if (managed.length === 0 || managed.length > segments.length)
+      return false;
+    for (let start = 0;start + managed.length <= segments.length; start += 1) {
+      if (managed.every((segment, offset) => segments[start + offset] === segment))
+        return true;
+    }
+    return false;
+  });
+}
+function readManifestRelativePaths(manifestPath) {
+  let stats;
+  try {
+    if (!existsSync6(manifestPath))
+      return null;
+    stats = statSync3(manifestPath);
+  } catch {
+    return null;
+  }
+  const cached = manifestCache.get(manifestPath);
+  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+    return cached.relativePaths;
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (manifest?.schema !== SESSION_RENDER_SCHEMA || !Array.isArray(manifest.files))
+    return null;
+  const writerId = manifest.targetOwner?.writer?.id;
+  if (writerId !== undefined && writerId !== SESSION_RENDERER_OWNER_ID)
+    return null;
+  const relativePaths = new Set(manifest.files.map((file) => file?.relativePath).filter((relativePath) => typeof relativePath === "string").map((relativePath) => relativePath.replaceAll("\\", "/")));
+  manifestCache.set(manifestPath, { mtimeMs: stats.mtimeMs, size: stats.size, relativePaths });
+  return relativePaths;
+}
+function sessionRenderManifestClaimsPath(absolutePath2) {
+  const root = parse3(absolutePath2).root;
+  let home = dirname3(absolutePath2);
+  for (let depth = 0;depth < MANIFEST_ANCESTOR_LIMIT; depth += 1) {
+    const manifestPath = join6(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
+    const relativePaths = readManifestRelativePaths(manifestPath);
+    if (relativePaths) {
+      const claimed = relative3(home, absolutePath2).split(sep).join("/");
+      if (relativePaths.has(claimed))
+        return true;
+    }
+    const parent = dirname3(home);
+    if (parent === home || home === root)
+      break;
+    home = parent;
+  }
+  return false;
+}
+function sessionRenderOwnsPath(absolutePath2) {
+  return pathIsSessionRenderManagedDir(absolutePath2) || sessionRenderManifestClaimsPath(absolutePath2);
+}
+var MANIFEST_ANCESTOR_LIMIT = 24, MANAGED_PATH_SEGMENTS, manifestCache;
+var init_session_render_ownership = __esm(() => {
+  init_session_render();
+  MANAGED_PATH_SEGMENTS = SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS.map((managedPath) => managedPath.split("/").filter(Boolean));
+  manifestCache = new Map;
+});
+
 // src/lib/apply.ts
 var exports_apply = {};
 __export(exports_apply, {
@@ -11257,8 +11531,8 @@ __export(exports_apply, {
   applyConfigs: () => applyConfigs,
   applyConfig: () => applyConfig
 });
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename4, dirname as dirname3, join as join6, resolve as resolve3 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename4, dirname as dirname4, join as join7, resolve as resolve3 } from "path";
 import { homedir as homedir4 } from "os";
 function getConfigHome() {
   return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir4();
@@ -11277,14 +11551,14 @@ function normalizeTargetPath(p) {
     let current = expanded;
     const missingSegments = [];
     while (true) {
-      if (existsSync6(current)) {
+      if (existsSync7(current)) {
         try {
           return resolve3(realpathSync2(current), ...missingSegments);
         } catch {
           return expanded;
         }
       }
-      const parent = dirname3(current);
+      const parent = dirname4(current);
       const name = basename4(current);
       if (parent === current)
         return expanded;
@@ -11306,11 +11580,11 @@ async function writeConfigResult(config, targetPath, content, opts, meta = {}) {
     throw new ConfigApplyError(`Antigravity rule file ${renderedTargetPath} is ${renderedContent.length} characters; split it before applying because Antigravity limits rule files to ${ANTIGRAVITY_RULE_FILE_CHAR_LIMIT} characters.`);
   }
   const path = expandPath(renderedTargetPath);
-  const previousContent = existsSync6(path) ? readFileSync3(path, "utf-8") : null;
+  const previousContent = existsSync7(path) ? readFileSync4(path, "utf-8") : null;
   const changed = previousContent !== renderedContent;
   if (!opts.dryRun) {
-    const dir = dirname3(path);
-    if (!existsSync6(dir)) {
+    const dir = dirname4(path);
+    if (!existsSync7(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     if (previousContent !== null && changed) {
@@ -11613,13 +11887,15 @@ function sessionRendererOwnsTarget(targetPath, opts) {
   return sessionRendererOwnsCanonicalTarget(canonicalApplyTargetPath(targetPath, opts), opts);
 }
 function sessionRendererOwnsCanonicalTarget(normalized, opts) {
+  if (opts.allowSessionRendererOwned)
+    return false;
   const homes = new Set([
     getConfigHome(),
     opts.vars?.["HOME_DIR"]
   ].filter((home) => typeof home === "string" && home.length > 0));
-  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join6(home, ...relativePath.split("/"))))))
+  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join7(home, ...relativePath.split("/"))))))
     return true;
-  return normalized.replaceAll("\\", "/").includes("/.agents/rules/");
+  return sessionRenderOwnsPath(normalized);
 }
 var init_apply = __esm(() => {
   init_types();
@@ -11627,12 +11903,13 @@ var init_apply = __esm(() => {
   init_config_agents();
   init_machine();
   init_session_render();
+  init_session_render_ownership();
   init_transforms();
 });
 
 // src/lib/sync-dir.ts
-import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import { join as join7, relative as relative3 } from "path";
+import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { join as join8, relative as relative4 } from "path";
 import { homedir as homedir5 } from "os";
 function shouldSkip(p) {
   return SKIP.some((s) => p.includes(s));
@@ -11640,9 +11917,9 @@ function shouldSkip(p) {
 async function syncFromDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const absDir = expandPath(dir);
-  if (!existsSync7(absDir))
+  if (!existsSync8(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync(absDir).map((f) => join7(absDir, f)).filter((f) => statSync3(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync(absDir).map((f) => join8(absDir, f)).filter((f) => statSync4(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
   const home = homedir5();
   const allConfigs = await store.listConfigs();
@@ -11652,7 +11929,7 @@ async function syncFromDir(dir, opts = {}) {
       continue;
     }
     try {
-      const content = readFileSync4(file, "utf-8");
+      const content = readFileSync5(file, "utf-8");
       if (content.length > 500000) {
         result.skipped.push(file + " (too large)");
         continue;
@@ -11661,7 +11938,7 @@ async function syncFromDir(dir, opts = {}) {
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative3(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
+          await store.createConfig({ name: relative4(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
         result.added++;
       } else if (existing.content !== content) {
         if (!opts.dryRun)
@@ -11702,7 +11979,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join7(dir, entry.name);
+    const full = join8(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -11736,8 +12013,8 @@ __export(exports_sync, {
   KNOWN_CONFIGS: () => KNOWN_CONFIGS,
   CLAUDE_PROMPT_OUTPUTS: () => CLAUDE_PROMPT_OUTPUTS
 });
-import { existsSync as existsSync8, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
-import { basename as basename5, extname as extname3, join as join8 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { basename as basename5, extname as extname3, join as join9 } from "path";
 function claudeRuleOutputs(fileName) {
   const stem = basename5(fileName, extname3(fileName));
   return [
@@ -11769,7 +12046,7 @@ function isGeneratedOutputTarget2(config, owners) {
   return !!ownerIds && !ownerIds.has(config.id);
 }
 function hasClaudePromptSource() {
-  return existsSync8(expandPath("~/.claude/CLAUDE.md"));
+  return existsSync9(expandPath("~/.claude/CLAUDE.md"));
 }
 function hasClaudeRuleSourceForCursorTarget(targetPath) {
   const absoluteTargetPath = expandPath(targetPath);
@@ -11777,7 +12054,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
   const stem = basename5(absoluteTargetPath, ".mdc");
-  return existsSync8(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync8(expandPath(`~/.claude/rules/${stem}.mdc`));
+  return existsSync9(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync9(expandPath(`~/.claude/rules/${stem}.mdc`));
 }
 function isKnownGeneratedTargetPath(targetPath) {
   const normalizedTargetPath = normalizeTargetPath(targetPath);
@@ -11794,11 +12071,11 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join8(absDir, pf.file);
-    if (!existsSync8(abs))
+    const abs = join9(absDir, pf.file);
+    if (!existsSync9(abs))
       continue;
     try {
-      const rawContent = readFileSync5(abs, "utf-8");
+      const rawContent = readFileSync6(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(pf.file);
         continue;
@@ -11827,15 +12104,15 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join8(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join8(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" }
+    { dir: join9(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join9(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" }
   ]) {
-    if (!existsSync8(ruleDir.dir))
+    if (!existsSync9(ruleDir.dir))
       continue;
     const mdFiles = readdirSync2(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join8(ruleDir.dir, f);
-      const raw = readFileSync5(abs, "utf-8");
+      const abs = join9(ruleDir.dir, f);
+      const raw = readFileSync6(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
@@ -11874,20 +12151,20 @@ async function syncKnown(opts = {}) {
   for (const known of targets) {
     if (known.rulesDir) {
       const absDir = expandPath(known.rulesDir);
-      if (!existsSync8(absDir)) {
+      if (!existsSync9(absDir)) {
         result.skipped.push(known.rulesDir);
         continue;
       }
       const extensions = known.rulesExtensions ?? [".md", ".mdc"];
       const ruleFiles = readdirSync2(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join8(absDir, f);
+        const abs2 = join9(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
           continue;
         }
-        const raw = readFileSync5(abs2, "utf-8");
+        const raw = readFileSync6(abs2, "utf-8");
         const redacted = redactContent(raw, "markdown");
         const machineAware = templateizeMachineContent(redacted.content, machine);
         const content = machineAware.content;
@@ -11915,12 +12192,12 @@ async function syncKnown(opts = {}) {
       continue;
     }
     const abs = expandPath(known.path);
-    if (!existsSync8(abs)) {
+    if (!existsSync9(abs)) {
       result.skipped.push(known.path);
       continue;
     }
     try {
-      const rawContent = readFileSync5(abs, "utf-8");
+      const rawContent = readFileSync6(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(known.path + " (too large)");
         continue;
@@ -12008,9 +12285,9 @@ async function syncToDisk(opts = {}) {
 }
 function buildDiff(expectedContent, targetPath) {
   const path = expandPath(targetPath);
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return `(file not found on disk: ${path})`;
-  const diskContent = readFileSync5(path, "utf-8");
+  const diskContent = readFileSync6(path, "utf-8");
   if (diskContent === expectedContent)
     return "(no diff \u2014 identical)";
   const stored = expectedContent.split(`
@@ -12195,16 +12472,16 @@ __export(exports_package_manager_guard, {
   scanPackageManagerSecrets: () => scanPackageManagerSecrets
 });
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync14, lstatSync as lstatSync3, readdirSync as readdirSync4, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync15, lstatSync as lstatSync3, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
 import { homedir as homedir6 } from "os";
-import { basename as basename6, dirname as dirname6, isAbsolute as isAbsolute4, join as join13, relative as relative5, resolve as resolve7 } from "path";
+import { basename as basename6, dirname as dirname7, isAbsolute as isAbsolute4, join as join14, relative as relative6, resolve as resolve7 } from "path";
 function scanPackageManagerSecrets(options = {}) {
   const cwd = options.cwd ? resolve7(options.cwd) : process.cwd();
   const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve7(cwd, root));
   const findings = [];
   let scannedFiles = 0;
   for (const root of roots) {
-    if (!existsSync14(root))
+    if (!existsSync15(root))
       continue;
     const stat = lstatSync3(root);
     if (stat.isFile()) {
@@ -12214,14 +12491,14 @@ function scanPackageManagerSecrets(options = {}) {
       if (text === null)
         continue;
       scannedFiles++;
-      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname6(root)));
+      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname7(root)));
       continue;
     }
     if (!stat.isDirectory())
       continue;
     const tracked = trackedFiles(root);
     for (const file of collectRepoFiles(root)) {
-      const rel = toPosix(relative5(root, file));
+      const rel = toPosix(relative6(root, file));
       const isTracked = tracked.has(rel);
       const text = readTextFile(file);
       if (text === null)
@@ -12233,8 +12510,8 @@ function scanPackageManagerSecrets(options = {}) {
   if (options.includeHome) {
     const home = homedir6();
     for (const name of HOME_FILES) {
-      const file = join13(home, name);
-      if (!existsSync14(file))
+      const file = join14(home, name);
+      if (!existsSync15(file))
         continue;
       const text = readTextFile(file);
       if (text === null)
@@ -12258,12 +12535,12 @@ function collectRepoFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
           continue;
-        visit(join13(dir, entry.name));
+        visit(join14(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const file = join13(dir, entry.name);
+      const file = join14(dir, entry.name);
       if (shouldScanRepoFile(file))
         out.push(file);
     }
@@ -12301,7 +12578,7 @@ function readTextFile(file) {
     const stat = lstatSync3(file);
     if (!stat.isFile() || stat.size > 5000000)
       return null;
-    const buf = readFileSync10(file);
+    const buf = readFileSync11(file);
     if (buf.includes(0))
       return null;
     return buf.toString("utf-8");
@@ -12501,11 +12778,11 @@ function trackedFiles(root) {
 }
 function isTrackedFile(file) {
   try {
-    const repoRoot = execFileSync2("git", ["-C", dirname6(file), "rev-parse", "--show-toplevel"], {
+    const repoRoot = execFileSync2("git", ["-C", dirname7(file), "rev-parse", "--show-toplevel"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    const rel = toPosix(relative5(repoRoot, file));
+    const rel = toPosix(relative6(repoRoot, file));
     execFileSync2("git", ["-C", repoRoot, "ls-files", "--error-unmatch", "--", rel], {
       stdio: ["ignore", "ignore", "ignore"]
     });
@@ -12533,11 +12810,11 @@ function stripInlineComment(value) {
 function displayPath(file, root) {
   const home = homedir6();
   if (root === home && (file === home || file.startsWith(home + "/")))
-    return "~/" + toPosix(relative5(home, file));
+    return "~/" + toPosix(relative6(home, file));
   if (isAbsolute4(root) && file.startsWith(root + "/"))
-    return toPosix(relative5(root, file));
+    return toPosix(relative6(root, file));
   if (file === home || file.startsWith(home + "/"))
-    return "~/" + toPosix(relative5(home, file));
+    return "~/" + toPosix(relative6(home, file));
   return file;
 }
 function toPosix(path) {
@@ -13286,21 +13563,21 @@ init_apply();
 init_sync();
 init_redact();
 import chalk from "chalk";
-import { existsSync as existsSync15, lstatSync as lstatSync4, readFileSync as readFileSync11, readSync, writeSync } from "fs";
+import { existsSync as existsSync16, lstatSync as lstatSync4, readFileSync as readFileSync12, readSync, writeSync } from "fs";
 import { homedir as homedir7 } from "os";
-import { basename as basename7, join as join14, resolve as resolve8 } from "path";
+import { basename as basename7, join as join15, resolve as resolve8 } from "path";
 
 // src/lib/export.ts
 init_config_store();
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join9, resolve as resolve4 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10, resolve as resolve4 } from "path";
 import { tmpdir } from "os";
 async function exportConfigs(outputPath, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const configs = await store.listConfigs(opts.filter);
   const absOutput = resolve4(outputPath);
-  const tmpDir = join9(tmpdir(), `configs-export-${Date.now()}`);
-  const contentsDir = join9(tmpDir, "contents");
+  const tmpDir = join10(tmpdir(), `configs-export-${Date.now()}`);
+  const contentsDir = join10(tmpDir, "contents");
   try {
     mkdirSync4(contentsDir, { recursive: true });
     const manifest = {
@@ -13308,10 +13585,10 @@ async function exportConfigs(outputPath, opts = {}) {
       exported_at: new Date().toISOString(),
       configs: configs.map(({ content: _content, ...meta }) => meta)
     };
-    writeFileSync3(join9(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+    writeFileSync3(join10(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
     for (const config of configs) {
       const fileName = `${config.slug}.${config.format === "text" ? "txt" : config.format}`;
-      writeFileSync3(join9(contentsDir, fileName), config.content, "utf-8");
+      writeFileSync3(join10(contentsDir, fileName), config.content, "utf-8");
     }
     const proc = Bun.spawn(["tar", "czf", absOutput, "-C", tmpDir, "."], {
       stdout: "pipe",
@@ -13324,7 +13601,7 @@ async function exportConfigs(outputPath, opts = {}) {
     }
     return { path: absOutput, count: configs.length };
   } finally {
-    if (existsSync9(tmpDir)) {
+    if (existsSync10(tmpDir)) {
       rmSync3(tmpDir, { recursive: true, force: true });
     }
   }
@@ -13332,14 +13609,14 @@ async function exportConfigs(outputPath, opts = {}) {
 
 // src/lib/import.ts
 init_config_store();
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync4 } from "fs";
-import { join as join10, resolve as resolve5 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync7, rmSync as rmSync4 } from "fs";
+import { join as join11, resolve as resolve5 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 async function importConfigs(bundlePath, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const conflict = opts.conflict ?? "skip";
   const absPath = resolve5(bundlePath);
-  const tmpDir = join10(tmpdir2(), `configs-import-${Date.now()}`);
+  const tmpDir = join11(tmpdir2(), `configs-import-${Date.now()}`);
   const result = { created: 0, updated: 0, skipped: 0, errors: [] };
   try {
     mkdirSync5(tmpDir, { recursive: true });
@@ -13352,15 +13629,15 @@ async function importConfigs(bundlePath, opts = {}) {
       const stderr = await new Response(proc.stderr).text();
       throw new Error(`tar extraction failed: ${stderr}`);
     }
-    const manifestPath = join10(tmpDir, "manifest.json");
-    if (!existsSync10(manifestPath))
+    const manifestPath = join11(tmpDir, "manifest.json");
+    if (!existsSync11(manifestPath))
       throw new Error("Invalid bundle: missing manifest.json");
-    const manifest = JSON.parse(readFileSync6(manifestPath, "utf-8"));
+    const manifest = JSON.parse(readFileSync7(manifestPath, "utf-8"));
     for (const meta of manifest.configs) {
       try {
         const ext = meta.format === "text" ? "txt" : meta.format;
-        const contentFile = join10(tmpDir, "contents", `${meta.slug}.${ext}`);
-        const content = existsSync10(contentFile) ? readFileSync6(contentFile, "utf-8") : "";
+        const contentFile = join11(tmpDir, "contents", `${meta.slug}.${ext}`);
+        const content = existsSync11(contentFile) ? readFileSync7(contentFile, "utf-8") : "";
         let existing = null;
         try {
           existing = await store.getConfig(meta.slug);
@@ -13394,7 +13671,7 @@ async function importConfigs(bundlePath, opts = {}) {
     }
     return result;
   } finally {
-    if (existsSync10(tmpDir)) {
+    if (existsSync11(tmpDir)) {
       rmSync4(tmpDir, { recursive: true, force: true });
     }
   }
@@ -13407,16 +13684,16 @@ init_machine();
 // src/lib/session-apply.ts
 init_project_context();
 init_session_render();
-import { createHash as createHash3, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID7 } from "crypto";
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   readdirSync as readdirSync3,
-  statSync as statSync4
+  statSync as statSync5
 } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join11, parse as parse3, relative as relative4, resolve as resolve6 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute3, join as join12, parse as parse4, relative as relative5, resolve as resolve6 } from "path";
 
 class SessionApplyError extends Error {
   constructor(message) {
@@ -13497,13 +13774,13 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   };
 }
 function ensureSessionTargetHome(targetHome) {
-  if (!existsSync11(targetHome))
+  if (!existsSync12(targetHome))
     mkdirSync6(targetHome, { recursive: true, mode: 448 });
   assertSafeTargetHome(targetHome);
 }
 function checkSessionRenderDrift(targetHome, manifestPath) {
   const safeTargetHome = assertSafeTargetHome(targetHome);
-  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative4(safeTargetHome, resolve6(manifestPath)), safeTargetHome) : resolve6(safeTargetHome, ".hasna", "session-render-manifest.json");
+  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative5(safeTargetHome, resolve6(manifestPath)), safeTargetHome) : resolve6(safeTargetHome, ".hasna", "session-render-manifest.json");
   const checkedAt = new Date().toISOString();
   const previousManifest = readPreviousManifest(resolvedManifestPath);
   if (!previousManifest) {
@@ -13520,7 +13797,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
   const drifted = [];
   for (const file of previousManifest.files) {
     const target = resolveManifestRelativePath(file.relativePath, safeTargetHome);
-    if (!existsSync11(target)) {
+    if (!existsSync12(target)) {
       missing.push({
         path: target,
         relativePath: file.relativePath,
@@ -13530,7 +13807,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
       });
       continue;
     }
-    const actualSha256 = sha2563(readFileSync7(target, "utf-8"));
+    const actualSha256 = sha2564(readFileSync8(target, "utf-8"));
     if (actualSha256 !== file.sha256) {
       drifted.push({
         path: target,
@@ -13554,7 +13831,7 @@ function restoreSessionRenderSnapshot(snapshotPath, options = {}) {
   const snapshot = readSessionRenderSnapshot(snapshotPath);
   const targetHome = assertSafeTargetHome(snapshot.targetHome);
   const resolvedSnapshotPath = resolve6(snapshotPath);
-  const snapshotRelativePath = relative4(targetHome, resolvedSnapshotPath);
+  const snapshotRelativePath = relative5(targetHome, resolvedSnapshotPath);
   if (snapshotRelativePath === "" || snapshotRelativePath === ".." || snapshotRelativePath.startsWith("../") || isAbsolute3(snapshotRelativePath)) {
     throw new SessionApplyError("Session snapshot must be stored inside its target home.");
   }
@@ -13672,18 +13949,18 @@ function requiredRestoreHash(file) {
 }
 function readSessionRenderSnapshot(snapshotPath) {
   const resolved = resolve6(snapshotPath);
-  if (!existsSync11(resolved))
+  if (!existsSync12(resolved))
     throw new SessionApplyError(`Session snapshot not found: ${snapshotPath}`);
   const stat = lstatSync2(resolved);
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw new SessionApplyError(`Session snapshot is not a regular file: ${snapshotPath}`);
   }
-  if (statSync4(resolved).size > 32 * 1024 * 1024) {
+  if (statSync5(resolved).size > 32 * 1024 * 1024) {
     throw new SessionApplyError(`Session snapshot exceeds the 32 MiB restore limit: ${snapshotPath}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync7(resolved, "utf8"));
+    parsed = JSON.parse(readFileSync8(resolved, "utf8"));
   } catch {
     throw new SessionApplyError(`Session snapshot is not valid JSON: ${snapshotPath}`);
   }
@@ -13705,7 +13982,7 @@ function readSessionRenderSnapshot(snapshotPath) {
   const previousManifest = snapshot.previousManifest;
   const previousFiles = new Map;
   for (const file of snapshot.files) {
-    if (!file || typeof file.relativePath !== "string" || typeof file.path !== "string" || typeof file.sha256 !== "string" || typeof file.content !== "string" || sha2563(file.content) !== file.sha256) {
+    if (!file || typeof file.relativePath !== "string" || typeof file.path !== "string" || typeof file.sha256 !== "string" || typeof file.content !== "string" || sha2564(file.content) !== file.sha256) {
       throw new SessionApplyError(`Session snapshot previous file metadata is invalid: ${snapshotPath}`);
     }
     resolveSnapshotFilePath(file.relativePath, file.path, targetHome);
@@ -13753,7 +14030,7 @@ function readSessionRenderSnapshot(snapshotPath) {
 function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previousManifestFiles, targetHome, snapshotPath) {
   assertNoNewerSessionSnapshot(snapshotPath, snapshot.createdAt, targetHome);
   const manifestPath = resolve6(snapshot.manifestPath);
-  const manifestRelativePath = relative4(targetHome, manifestPath).replaceAll("\\", "/");
+  const manifestRelativePath = relative5(targetHome, manifestPath).replaceAll("\\", "/");
   resolveSnapshotFilePath(manifestRelativePath, snapshot.manifestPath, targetHome);
   const manifestSha256 = currentSessionFileHash(manifestPath, targetHome);
   if (manifestSha256 === null) {
@@ -13761,7 +14038,7 @@ function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previou
   }
   let parsedManifest;
   try {
-    parsedManifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
+    parsedManifest = JSON.parse(readFileSync8(manifestPath, "utf8"));
   } catch {
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest is not valid JSON: ${snapshotPath}`);
   }
@@ -13853,15 +14130,15 @@ function assertNoNewerSessionSnapshot(snapshotPath, createdAt, targetHome) {
   if (!Number.isFinite(createdAtMs)) {
     throw new SessionApplyError(`Pre-rollback legacy v1 snapshot has an invalid creation time: ${snapshotPath}`);
   }
-  for (const entry of readdirSync3(dirname4(snapshotPath))) {
-    const candidatePath = resolve6(dirname4(snapshotPath), entry);
+  for (const entry of readdirSync3(dirname5(snapshotPath))) {
+    const candidatePath = resolve6(dirname5(snapshotPath), entry);
     if (candidatePath === resolve6(snapshotPath) || !entry.endsWith(".json"))
       continue;
     const candidateStat = lstatSync2(candidatePath);
     if (candidateStat.isSymbolicLink() || !candidateStat.isFile() || candidateStat.size > 32 * 1024 * 1024)
       continue;
     try {
-      const candidate = JSON.parse(readFileSync7(candidatePath, "utf8"));
+      const candidate = JSON.parse(readFileSync8(candidatePath, "utf8"));
       const candidateCreatedAtMs = typeof candidate.createdAt === "string" ? Date.parse(candidate.createdAt) : Number.NaN;
       if ((candidate.schema === "hasna.configs.session-render-snapshot/v1" || candidate.schema === "hasna.configs.session-render-snapshot/v2") && typeof candidate.targetHome === "string" && resolve6(candidate.targetHome) === targetHome && Number.isFinite(candidateCreatedAtMs) && candidateCreatedAtMs >= createdAtMs) {
         throw new SessionApplyError(`Cannot restore pre-rollback legacy v1 snapshot after a newer session snapshot exists: ${candidatePath}`);
@@ -13921,7 +14198,7 @@ function inferLegacySnapshotAction(file, previousFiles, previousManifestFiles, p
     return "create";
   }
   if (file.role === "manifest" && previousManifest) {
-    const previousManifestSha256 = sha2563(`${JSON.stringify(previousManifest, null, 2)}
+    const previousManifestSha256 = sha2564(`${JSON.stringify(previousManifest, null, 2)}
 `);
     if (previousManifestSha256 !== file.sha256) {
       throw new SessionApplyError(`Cannot infer legacy v1 manifest action without a before-image: ${file.relativePath}`);
@@ -13939,8 +14216,8 @@ function resolveSnapshotFilePath(relativePath, recordedPath, targetHome) {
 }
 function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options) {
   const target = resolvePlannedFilePath(plan, file, targetHome);
-  const previousContent = existsSync11(target) ? readFileSync7(target, "utf-8") : null;
-  const previousSha256 = previousContent === null ? null : sha2563(previousContent);
+  const previousContent = existsSync12(target) ? readFileSync8(target, "utf-8") : null;
+  const previousSha256 = previousContent === null ? null : sha2564(previousContent);
   const previouslyManaged = isPreviouslyManaged(file, previousSha256, previousHashes, previousManifest);
   const changed = previousContent !== file.content;
   if (previousContent !== null && !options.force && !previouslyManaged) {
@@ -14022,10 +14299,10 @@ function planStaleFileResults(plan, targetHome, previousManifest, currentRelativ
 }
 function planStaleFileResult(file, targetHome, options) {
   const target = resolveManifestRelativePath(file.relativePath, targetHome);
-  if (!existsSync11(target))
+  if (!existsSync12(target))
     return null;
-  const previousContent = readFileSync7(target, "utf-8");
-  const previousSha256 = sha2563(previousContent);
+  const previousContent = readFileSync8(target, "utf-8");
+  const previousSha256 = sha2564(previousContent);
   if (!options.force && previousSha256 !== file.sha256) {
     return {
       path: target,
@@ -14070,7 +14347,7 @@ function isPreviouslyManaged(file, previousSha256, previousHashes, previousManif
 }
 function resolvePlannedFilePath(plan, file, targetHome) {
   const target = resolve6(targetHome, ...file.relativePath.split("/"));
-  const rel = relative4(targetHome, target);
+  const rel = relative5(targetHome, target);
   if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute3(rel)) {
     throw new SessionApplyError(`Session file escapes target home: ${file.relativePath}`);
   }
@@ -14082,7 +14359,7 @@ function resolvePlannedFilePath(plan, file, targetHome) {
 }
 function resolveManifestRelativePath(relativePath, targetHome) {
   const target = resolve6(targetHome, ...relativePath.split(/[\\/]+/));
-  const rel = relative4(targetHome, target);
+  const rel = relative5(targetHome, target);
   if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute3(rel)) {
     throw new SessionApplyError(`Session manifest file escapes target home: ${relativePath}`);
   }
@@ -14090,10 +14367,10 @@ function resolveManifestRelativePath(relativePath, targetHome) {
   return target;
 }
 function readPreviousManifest(path) {
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
     if (parsed.schema !== SESSION_RENDER_SCHEMA)
       return null;
     if (!Array.isArray(parsed.files))
@@ -14127,18 +14404,18 @@ function applyPlannedFile(plan, file, targetHome, resultsByPath, coordination, a
 function assertExpectedSessionFileHash(path, targetHome, expectedHash) {
   const actualHash = currentSessionFileHash(path, targetHome);
   if (actualHash !== expectedHash) {
-    throw new SessionApplyError(`Session apply path changed after planning: ${relative4(targetHome, path)}`);
+    throw new SessionApplyError(`Session apply path changed after planning: ${relative5(targetHome, path)}`);
   }
 }
 function currentSessionFileHash(path, targetHome) {
   assertNoSymlinkSegments2(targetHome, path);
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return null;
   const stat = lstatSync2(path);
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw new SessionApplyError(`Session apply path is not a regular file: ${path}`);
   }
-  return sha2563(readFileSync7(path, "utf-8"));
+  return sha2564(readFileSync8(path, "utf-8"));
 }
 function requiredPreviousHash(result) {
   if (result.previousSha256 === null) {
@@ -14147,13 +14424,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) => existsSync11(result.path)).map((result) => {
-    const content = readFileSync7(result.path, "utf-8");
+  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").filter((result) => existsSync12(result.path)).map((result) => {
+    const content = readFileSync8(result.path, "utf-8");
     return {
       path: result.path,
       relativePath: result.relativePath,
       role: result.role,
-      sha256: sha2563(content),
+      sha256: sha2564(content),
       content
     };
   });
@@ -14204,42 +14481,42 @@ function assertSafeTargetHome(targetHome) {
   if (!isAbsolute3(targetHome))
     throw new SessionApplyError(`Session target home must be absolute: ${targetHome}`);
   const normalized = resolve6(targetHome);
-  if (normalized === parse3(normalized).root) {
+  if (normalized === parse4(normalized).root) {
     throw new SessionApplyError(`Session target home cannot be the filesystem root: ${targetHome}`);
   }
   assertNoSymlinkAncestors2(normalized);
-  if (existsSync11(normalized) && lstatSync2(normalized).isSymbolicLink()) {
+  if (existsSync12(normalized) && lstatSync2(normalized).isSymbolicLink()) {
     throw new SessionApplyError(`Session target home cannot be a symlink: ${normalized}`);
   }
   return normalized;
 }
 function assertNoSymlinkSegments2(root, target) {
   assertNoSymlinkAncestors2(root);
-  const rel = relative4(root, target);
+  const rel = relative5(root, target);
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join11(current, segment);
-    if (existsSync11(current) && lstatSync2(current).isSymbolicLink()) {
+    current = join12(current, segment);
+    if (existsSync12(current) && lstatSync2(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink: ${current}`);
     }
   }
 }
 function assertNoSymlinkAncestors2(path) {
   const normalized = resolve6(path);
-  const parsed = parse3(normalized);
+  const parsed = parse4(normalized);
   let current = parsed.root;
-  const rel = relative4(parsed.root, normalized);
+  const rel = relative5(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join11(current, segment);
-    if (!existsSync11(current))
+    current = join12(current, segment);
+    if (!existsSync12(current))
       return;
     if (lstatSync2(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink ancestor: ${current}`);
     }
   }
 }
-function sha2563(content) {
-  return createHash3("sha256").update(content).digest("hex");
+function sha2564(content) {
+  return createHash4("sha256").update(content).digest("hex");
 }
 
 // src/cli/index.tsx
@@ -14557,28 +14834,28 @@ init_project_context();
 init_config_store();
 init_apply();
 init_config_agents();
-import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
 
 // src/lib/package-version.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
-import { dirname as dirname5, join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
 import { fileURLToPath } from "url";
 var cached = null;
 function getPackageVersion() {
   if (cached)
     return cached;
   try {
-    let dir = dirname5(fileURLToPath(import.meta.url));
+    let dir = dirname6(fileURLToPath(import.meta.url));
     for (let i = 0;i < 8; i++) {
-      const pkgPath = join12(dir, "package.json");
-      if (existsSync12(pkgPath)) {
-        const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
+      const pkgPath = join13(dir, "package.json");
+      if (existsSync13(pkgPath)) {
+        const pkg = JSON.parse(readFileSync9(pkgPath, "utf8"));
         if (pkg.name === "@hasna/instructions" && pkg.version) {
           cached = pkg.version;
           return cached;
         }
       }
-      const parent = dirname5(dir);
+      const parent = dirname6(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -14635,11 +14912,11 @@ async function getConfigsStatus(store = resolveConfigStore()) {
       continue;
     knownTargets += 1;
     const targetPath = expandPath(config.target_path);
-    if (!existsSync13(targetPath)) {
+    if (!existsSync14(targetPath)) {
       missingTargets += 1;
       continue;
     }
-    const disk = readFileSync9(targetPath, "utf-8");
+    const disk = readFileSync10(targetPath, "utf-8");
     const { content: redactedDisk } = redactContent(disk, config.format);
     if (redactedDisk !== config.content) {
       driftedTargets += 1;
@@ -14865,9 +15142,9 @@ function parseSessionSource(value, order, replaceIds) {
   if (!path)
     throw new Error(`Invalid --source "${value}" (expected path or id=path)`);
   const absPath = resolveSessionPath(path);
-  if (!existsSync15(absPath))
+  if (!existsSync16(absPath))
     throw new Error(`Instruction source file not found: ${absPath}`);
-  const content = readFileSync11(absPath, "utf-8");
+  const content = readFileSync12(absPath, "utf-8");
   const source = sourceFromFilePath(absPath, content, order);
   const resolvedId = id || source.id || basename7(absPath);
   return {
@@ -14903,9 +15180,9 @@ async function collectSessionSources(opts, tool, store) {
   }
   for (const value of opts.identityExport ?? []) {
     const path = resolveSessionPath(value);
-    if (!existsSync15(path))
+    if (!existsSync16(path))
       throw new Error(`Identity instruction export not found: ${path}`);
-    const parsed = JSON.parse(readFileSync11(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf-8"));
     sources.push(...sourcesFromIdentityExport(parsed, { path, tool, orderOffset: sources.length }));
   }
   return sources.map((source) => replaceIds.has(source.id) ? { ...source, merge: "replace" } : source);
@@ -14935,7 +15212,7 @@ function readProjectContextBundleOption(value, allowMissing = false) {
   if (value === "-")
     return { json: readBoundedProjectContextStdin() };
   const path = resolveSessionPath(value);
-  if (!existsSync15(path)) {
+  if (!existsSync16(path)) {
     if (allowMissing)
       return {};
     throw new ProjectContextError("PROJECT_CONTEXT_INPUT_MISSING", `bundle file not found: ${path}`);
@@ -14947,7 +15224,7 @@ function readProjectContextBundleOption(value, allowMissing = false) {
   if (stat.size > PROJECT_CONTEXT_MAX_INPUT_BYTES) {
     throw new ProjectContextError("PROJECT_CONTEXT_INPUT_TOO_LARGE", `bundle exceeds ${PROJECT_CONTEXT_MAX_INPUT_BYTES} bytes`);
   }
-  return { json: readFileSync11(path, "utf8"), sourcePath: path };
+  return { json: readFileSync12(path, "utf8"), sourcePath: path };
 }
 function readBoundedProjectContextStdin() {
   const chunks = [];
@@ -15075,11 +15352,11 @@ program.command("show <id>").alias("inspect").description("Show a config's conte
 });
 program.command("add <path>").description("Ingest a file into the config DB").option("-n, --name <name>", "config name (defaults to filename)").option("-c, --category <cat>", "category override").option("-a, --agent <agent>", "agent override").option("-k, --kind <kind>", "kind: file|reference", "file").option("--template", "mark as template (has {{VAR}} placeholders)").action(async (filePath, opts) => {
   const abs = resolve8(filePath);
-  if (!existsSync15(abs)) {
+  if (!existsSync16(abs)) {
     console.error(chalk.red(`File not found: ${abs}`));
     process.exit(1);
   }
-  const rawContent = readFileSync11(abs, "utf-8");
+  const rawContent = readFileSync12(abs, "utf-8");
   const fmt = detectFormat(abs);
   const { content, redacted, isTemplate: isTemplate2 } = redactContent(rawContent, fmt);
   const targetPath = abs.startsWith(homedir7()) ? abs.replace(homedir7(), "~") : abs;
@@ -15117,11 +15394,15 @@ program.command("delete <id>").alias("rm").description("Delete a config record (
     process.exit(1);
   }
 });
-program.command("apply <id>").description("Apply a config to its target_path and output targets on disk").option("--dry-run", "preview without writing").option("--force", "overwrite even if unchanged").action(async (id, opts) => {
+program.command("apply <id>").description("Apply a config to its target_path and output targets on disk").option("--dry-run", "preview without writing").option("--force", "overwrite even if unchanged").option("--allow-renderer-owned", "write even when the target is owned by the Instructions session renderer (opt-in; normally use `instructions session apply`)").action(async (id, opts) => {
   try {
     const store = resolveConfigStore();
     const config = await store.getConfig(id);
-    const report = await applyConfigsWithReport([config], { dryRun: opts.dryRun, store });
+    const report = await applyConfigsWithReport([config], {
+      dryRun: opts.dryRun,
+      store,
+      allowSessionRendererOwned: opts.allowRendererOwned
+    });
     if (report.failures.length > 0) {
       throw new Error(report.failures.map((failure) => failure.message).join("; "));
     }
@@ -15199,7 +15480,7 @@ program.command("sync").description("Sync known AI coding configs from disk into
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const projDir = join14(absDir, entry.name);
+        const projDir = join15(absDir, entry.name);
         const hasAgentConfig = [
           "CLAUDE.md",
           ".mcp.json",
@@ -15212,7 +15493,7 @@ program.command("sync").description("Sync known AI coding configs from disk into
           ".aicopilot",
           ".cursor",
           ".agents"
-        ].some((marker) => existsSync15(join14(projDir, marker)));
+        ].some((marker) => existsSync16(join15(projDir, marker)));
         if (!hasAgentConfig)
           continue;
         const result2 = await syncProject({ projectDir: projDir, dryRun: opts.dryRun, store });
@@ -15263,7 +15544,7 @@ program.command("import <file>").description("Import configs from a tar.gz bundl
 });
 program.command("whoami").description("Show setup summary").action(async () => {
   const store = resolveConfigStore();
-  const dbPath = isCloudMode() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1 (self_hosted)` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join14(homedir7(), ".hasna", "instructions", "instructions.db");
+  const dbPath = isCloudMode() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1 (self_hosted)` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join15(homedir7(), ".hasna", "instructions", "instructions.db");
   const stats = await store.getConfigStats();
   console.log(chalk.bold("@hasna/instructions") + chalk.dim(" v" + pkg.version));
   console.log(chalk.cyan(isCloudMode() ? "API:" : "DB:") + " " + dbPath);
@@ -15889,7 +16170,7 @@ command = "${mcpBinary}"
 args = []
 `;
         if (ex(configPath)) {
-          const content = readFileSync11(configPath, "utf-8");
+          const content = readFileSync12(configPath, "utf-8");
           if (content.includes("[mcp_servers.configs]")) {
             console.log(chalk.dim("= Already installed in Codex"));
             continue;
@@ -15983,7 +16264,7 @@ DB stats:`));
     if (count > 0)
       console.log(`  ${key.padEnd(18)} ${count}`);
   }
-  const location = isCloudMode() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1 (self_hosted)` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join14(homedir7(), ".hasna", "instructions", "instructions.db");
+  const location = isCloudMode() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1 (self_hosted)` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join15(homedir7(), ".hasna", "instructions", "instructions.db");
   console.log(chalk.dim(`
 ${isCloudMode() ? "API" : "DB"}: ${location}`));
 });
@@ -16005,10 +16286,10 @@ program.command("status").description("Health check: total configs, drift from d
 });
 program.command("backup").description("Export configs to a timestamped backup file").action(async () => {
   const { mkdirSync: mk } = await import("fs");
-  const backupDir = join14(homedir7(), ".hasna", "instructions", "backups");
+  const backupDir = join15(homedir7(), ".hasna", "instructions", "backups");
   mk(backupDir, { recursive: true });
   const ts = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "-").slice(0, 19);
-  const outPath = join14(backupDir, `configs-${ts}.tar.gz`);
+  const outPath = join15(backupDir, `configs-${ts}.tar.gz`);
   const result = await exportConfigs(outPath, { store: resolveConfigStore() });
   const { statSync: st } = await import("fs");
   const size = st(outPath).size;
@@ -16036,9 +16317,9 @@ program.command("doctor").description("Validate configs: syntax, permissions, mi
   console.log(chalk.cyan("Known files on disk:"));
   for (const k of KNOWN_CONFIGS) {
     if (k.rulesDir) {
-      existsSync15(expandPath(k.rulesDir)) ? pass(`${k.rulesDir}/ exists`) : k.optional ? skip(`${k.rulesDir}/ (optional)`) : fail(`${k.rulesDir}/ not found`);
+      existsSync16(expandPath(k.rulesDir)) ? pass(`${k.rulesDir}/ exists`) : k.optional ? skip(`${k.rulesDir}/ (optional)`) : fail(`${k.rulesDir}/ not found`);
     } else {
-      existsSync15(expandPath(k.path)) ? pass(k.path) : k.optional ? skip(`${k.path} (optional)`) : fail(`${k.path} not found`);
+      existsSync16(expandPath(k.path)) ? pass(k.path) : k.optional ? skip(`${k.path} (optional)`) : fail(`${k.path} not found`);
     }
   }
   const allConfigs = await store.listConfigs();
@@ -16163,16 +16444,16 @@ program.command("watch").description("Watch known config files for changes and a
   for (const k of KNOWN_CONFIGS) {
     if (k.rulesDir) {
       const absDir = expandPath2(k.rulesDir);
-      if (!existsSync15(absDir))
+      if (!existsSync16(absDir))
         continue;
       const { readdirSync: readdirSync5 } = await import("fs");
       for (const f of readdirSync5(absDir).filter((f2) => f2.endsWith(".md"))) {
-        const abs = join14(absDir, f);
+        const abs = join15(absDir, f);
         mtimes.set(abs, st(abs).mtimeMs);
       }
     } else {
       const abs = expandPath2(k.path);
-      if (existsSync15(abs))
+      if (existsSync16(abs))
         mtimes.set(abs, st(abs).mtimeMs);
     }
   }
@@ -16180,7 +16461,7 @@ program.command("watch").description("Watch known config files for changes and a
   const tick = async () => {
     let changed = 0;
     for (const [abs, oldMtime] of mtimes) {
-      if (!existsSync15(abs))
+      if (!existsSync16(abs))
         continue;
       const newMtime = st(abs).mtimeMs;
       if (newMtime !== oldMtime) {
@@ -16192,10 +16473,10 @@ program.command("watch").description("Watch known config files for changes and a
     for (const k of KNOWN_CONFIGS) {
       if (k.rulesDir) {
         const absDir = expandPath2(k.rulesDir);
-        if (!existsSync15(absDir))
+        if (!existsSync16(absDir))
           continue;
         for (const f of rd(absDir).filter((f2) => f2.endsWith(".md"))) {
-          const abs = join14(absDir, f);
+          const abs = join15(absDir, f);
           if (!mtimes.has(abs)) {
             mtimes.set(abs, st(abs).mtimeMs);
             changed++;
@@ -16203,7 +16484,7 @@ program.command("watch").description("Watch known config files for changes and a
         }
       } else {
         const abs = expandPath2(k.path);
-        if (existsSync15(abs) && !mtimes.has(abs)) {
+        if (existsSync16(abs) && !mtimes.has(abs)) {
           mtimes.set(abs, st(abs).mtimeMs);
           changed++;
         }
@@ -16231,11 +16512,11 @@ program.command("report").description("Summary of stored configs, drift, and eco
     if (!c.target_path)
       continue;
     const abs = expandPath(c.target_path);
-    if (!existsSync15(abs)) {
+    if (!existsSync16(abs)) {
       missing++;
       continue;
     }
-    const disk = readFileSync11(abs, "utf-8");
+    const disk = readFileSync12(abs, "utf-8");
     const { content: redactedDisk } = redactContent(disk, c.format);
     if (redactedDisk !== c.content)
       drifted++;
@@ -16276,7 +16557,7 @@ program.command("clean").description("Remove configs from DB whose target files
     if (!c.target_path)
       continue;
     const abs = expandPath(c.target_path);
-    if (!existsSync15(abs)) {
+    if (!existsSync16(abs)) {
       if (printed < maxPrinted) {
         if (opts.dryRun) {
           console.log(chalk.yellow("  would remove:") + ` ${c.slug} ${chalk.dim(`(${truncateMiddle(c.target_path, 88)})`)}`);