@hasna/instructions 0.4.8 → 0.4.10

package/dist/index.js

@@ -1100,11 +1100,11 @@ function resolveConfigStore(env = process.env) {
   return cloud ? new CloudConfigStore(cloud) : new LocalConfigStore;
 }
 // src/status.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
 
 // src/lib/apply.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename4, dirname as dirname3, join as join5, resolve as resolve3 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename4, dirname as dirname4, join as join6, resolve as resolve3 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/lib/config-agents.ts
@@ -1127,18 +1127,23 @@ function retiredOrUnsupportedAgentReason(agent) {
 }
 
 // src/lib/session-render.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync2, realpathSync, statSync as statSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { basename as basename3, dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join4, parse as parse2, posix, relative as relative2, resolve as resolve2 } from "path";
 
 // src/lib/global-agent-rules-standard.ts
+import { createHash } from "crypto";
 var GLOBAL_AGENT_RULES_STANDARD_SLUG = "global-agent-rules-standard";
 var AGENT_OPERATING_RULES_SOURCE_SET_ID = "hasna-global-agent-rules-standard";
 var AGENT_OPERATING_RULES_SOURCE_ID = "hasna-agent-operating-rules";
+var AGENT_OPERATING_RULES_ROLE = "agent-operating-rules";
 var AGENT_OPERATING_RULES_VERSION = "1.1.6";
 var AGENT_OPERATING_RULES_SOURCE_SET_VERSION = "2026-07-23";
 var AGENT_OPERATING_RULES_SENTINEL = "<!-- hasna:agent-operating-rules v=1.1.6 -->";
+var AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY = "hasna:agent-operating-rules";
+var AGENT_OPERATING_RULES_SENTINEL_PATTERN = /<!--\s*hasna:agent-operating-rules\s+v=([0-9]+\.[0-9]+\.[0-9]+)\s*-->/i;
+var 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})\)/;
 var AGENT_OPERATING_RULES_PAYLOAD_SHA256 = "8b236086b82e94490516e0b00dffa03fb5f6841b68d95f80fc3e3c8fb7087420";
 var AGENT_OPERATING_RULES_UPSTREAM_FILE_SHA256 = "b8e89cdb49e207e5b497ac51384d67022b94fe5645cc9273db60384eb2c2fb32";
 var SCOPED_OPERATIONAL_CONTROL_POLICY_REFERENCE = "hasna-agent-operating-rules/scoped-operational-control/v1";
@@ -1170,7 +1175,7 @@ var AGENT_OPERATING_RULES_PROVENANCE = {
 };
 var 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,
@@ -1179,7 +1184,7 @@ var AGENT_OPERATING_RULES_METADATA = {
   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
   }
@@ -1219,37 +1224,120 @@ var GLOBAL_AGENT_RULES_STANDARD_CONTENT = [
 ].join(`
 `) + `
 `;
-async function ensureGlobalAgentRulesStandardConfig(store = resolveConfigStore()) {
-  const input = {
+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;
 }
 
 // src/lib/project-context.ts
-import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
 import { execFileSync } from "child_process";
 import { dlopen, FFIType } from "bun:ffi";
 import {
@@ -5432,6 +5520,10 @@ function hasSecrets(content, format) {
 var CODEWITH_NATIVE_IMPORTS_ENV = "HASNA_CONFIGS_CODEWITH_NATIVE_IMPORTS";
 var SESSION_RENDER_MANAGED_MARKER = "Managed by @hasna/configs session render";
 var SESSION_RENDER_SCHEMA = "hasna.configs.session-render/v1";
+var SESSION_RENDER_MANAGED_NAMESPACE = ".hasna";
+var SESSION_RENDER_INSTRUCTIONS_MANAGED_DIR = `${SESSION_RENDER_MANAGED_NAMESPACE}/instructions`;
+var SESSION_RENDER_MANIFEST_RELATIVE_PATH = `${SESSION_RENDER_MANAGED_NAMESPACE}/session-render-manifest.json`;
+var SESSION_RENDER_SNAPSHOT_RELATIVE_DIR = `${SESSION_RENDER_MANAGED_NAMESPACE}/session-render-snapshots`;
 var SESSION_INSTRUCTION_LAYERS = [
   "global",
   "tool",
@@ -5608,7 +5700,7 @@ class ProjectContextHashRace extends Error {
 }
 function computeProjectContextSourceHash(value) {
   const normalized = removeHashForFingerprint(value);
-  return `sha256:${sha256(stableStringify(normalized))}`;
+  return `sha256:${sha2562(stableStringify(normalized))}`;
 }
 function parseProjectContextBundle(input) {
   let encoded;
@@ -5778,7 +5870,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)) {
@@ -5979,7 +6071,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)}`);
     }
   }
@@ -6199,7 +6291,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);
@@ -6269,14 +6361,14 @@ function buildManifest(plan, now2) {
       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"]
     }
   ];
@@ -6353,7 +6445,7 @@ function buildSessionCompatibilityManifest(plan, now2) {
     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"] : {};
@@ -6381,7 +6473,7 @@ function buildSessionCompatibilityManifest(plan, now2) {
     blockers: [],
     generatedAt: now2.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],
@@ -6584,7 +6676,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,
@@ -6706,7 +6798,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" });
@@ -6715,7 +6807,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) {
@@ -6724,8 +6816,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)) {
@@ -6733,7 +6825,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)}`);
@@ -6750,7 +6843,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);
@@ -6816,7 +6909,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;
@@ -6847,7 +6940,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);
@@ -6890,7 +6983,7 @@ function atomicWritePortableReplacement(path, content, workspaceRoot, expectedHa
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
   const tempPath = join3(dir, `.project-context-${randomUUID3()}.tmp`);
-  const desiredHash = sha256(content);
+  const desiredHash = sha2562(content);
   let fd = null;
   let tempIdentity = null;
   try {
@@ -6905,7 +6998,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);
@@ -6929,6 +7022,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);
@@ -6941,10 +7048,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);
@@ -7089,15 +7196,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(join3(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);
@@ -7115,7 +7250,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 {
@@ -7125,6 +7260,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, join3(path, ".project-context-directory-guard"));
   let stat;
@@ -7295,7 +7437,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 {
@@ -7346,7 +7488,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, ".."));
@@ -7363,7 +7505,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;
@@ -7525,7 +7667,7 @@ function releaseWorkspaceLock(lockPath, lock, workspaceRoot) {
       created_at: new Date().toISOString()
     })}
 `;
-    releaseHash = sha256(releaseContent);
+    releaseHash = sha2562(releaseContent);
     writeFileSync(releaseFd, releaseContent);
     fsyncSync(releaseFd);
     closeSync(releaseFd);
@@ -7764,7 +7906,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) {
@@ -7933,8 +8075,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);
@@ -8078,7 +8220,7 @@ var CODEWITH_FLATTENED_ADAPTER = {
   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."
@@ -8087,7 +8229,7 @@ var CODEWITH_NATIVE_ADAPTER = {
   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."
@@ -8097,7 +8239,7 @@ var SESSION_TOOL_ADAPTERS = {
     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."
@@ -8106,7 +8248,7 @@ var SESSION_TOOL_ADAPTERS = {
     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."
@@ -8123,7 +8265,7 @@ var SESSION_TOOL_ADAPTERS = {
     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."
@@ -8132,7 +8274,7 @@ var SESSION_TOOL_ADAPTERS = {
     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."
@@ -8155,6 +8297,19 @@ var SESSION_TOOL_ADAPTERS = {
   },
   codewith: CODEWITH_FLATTENED_ADAPTER
 };
+var SESSION_RENDER_MANAGED_DIRS = [
+  ...new Set([
+    CODEWITH_FLATTENED_ADAPTER,
+    CODEWITH_NATIVE_ADAPTER,
+    ...Object.values(SESSION_TOOL_ADAPTERS)
+  ].map((adapter) => adapter.managedDir))
+];
+var SESSION_RENDER_SHARED_MANAGED_DIRS = [".cursor/rules"];
+var 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
+];
 var SESSION_LAYER_RANK = {
   global: 10,
   tool: 20,
@@ -8184,11 +8339,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))
@@ -8254,18 +8409,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),
@@ -8288,30 +8484,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;
 }
@@ -8321,7 +8523,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;
 }
@@ -8810,7 +9012,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
       })),
@@ -8828,8 +9030,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: !existsSync4(joinTarget(targetHome, adapter.configFile))
       }
     } : {},
@@ -8873,15 +9075,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
     } : {
@@ -8889,7 +9092,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
   };
 }
@@ -8927,7 +9130,7 @@ function selectProfileConfigsForSessionRender(configs, tool) {
   const selectedSources = [];
   const equivalentSources = new Map;
   for (const candidate of sources) {
-    const key = sha2562(candidate.source.content);
+    const key = sha2563(candidate.source.content);
     const existing = equivalentSources.get(key);
     if (!existing) {
       equivalentSources.set(key, {
@@ -9273,6 +9476,77 @@ function asStringArray(value) {
   return value.filter((item) => typeof item === "string");
 }
 
+// src/lib/session-render-ownership.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { dirname as dirname3, join as join5, parse as parse3, relative as relative3, sep } from "path";
+var MANIFEST_ANCESTOR_LIMIT = 24;
+var MANAGED_PATH_SEGMENTS = SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS.map((managedPath) => managedPath.split("/").filter(Boolean));
+var manifestCache = new Map;
+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 (!existsSync5(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 = join5(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);
+}
+
 // src/lib/apply.ts
 function getConfigHome() {
   return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir3();
@@ -9291,14 +9565,14 @@ function normalizeTargetPath(p) {
     let current = expanded;
     const missingSegments = [];
     while (true) {
-      if (existsSync5(current)) {
+      if (existsSync6(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;
@@ -9320,11 +9594,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 = existsSync5(path) ? readFileSync3(path, "utf-8") : null;
+  const previousContent = existsSync6(path) ? readFileSync4(path, "utf-8") : null;
   const changed = previousContent !== renderedContent;
   if (!opts.dryRun) {
-    const dir = dirname3(path);
-    if (!existsSync5(dir)) {
+    const dir = dirname4(path);
+    if (!existsSync6(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     if (previousContent !== null && changed) {
@@ -9627,35 +9901,37 @@ 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(join5(home, ...relativePath.split("/"))))))
+  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join6(home, ...relativePath.split("/"))))))
     return true;
-  return normalized.replaceAll("\\", "/").includes("/.agents/rules/");
+  return sessionRenderOwnsPath(normalized);
 }
 
 // src/lib/package-version.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath } from "url";
 var cached = null;
 function getPackageVersion() {
   if (cached)
     return cached;
   try {
-    let dir = dirname4(fileURLToPath(import.meta.url));
+    let dir = dirname5(fileURLToPath(import.meta.url));
     for (let i = 0;i < 8; i++) {
-      const pkgPath = join6(dir, "package.json");
-      if (existsSync6(pkgPath)) {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+      const pkgPath = join7(dir, "package.json");
+      if (existsSync7(pkgPath)) {
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
         if (pkg.name === "@hasna/instructions" && pkg.version) {
           cached = pkg.version;
           return cached;
         }
       }
-      const parent = dirname4(dir);
+      const parent = dirname5(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -9711,11 +9987,11 @@ async function getConfigsStatus(store = resolveConfigStore()) {
       continue;
     knownTargets += 1;
     const targetPath = expandPath(config.target_path);
-    if (!existsSync7(targetPath)) {
+    if (!existsSync8(targetPath)) {
       missingTargets += 1;
       continue;
     }
-    const disk = readFileSync5(targetPath, "utf-8");
+    const disk = readFileSync6(targetPath, "utf-8");
     const { content: redactedDisk } = redactContent(disk, config.format);
     if (redactedDisk !== config.content) {
       driftedTargets += 1;
@@ -9858,16 +10134,16 @@ var PG_MIGRATIONS = [
   `ALTER TABLE configs ADD COLUMN IF NOT EXISTS outputs TEXT NOT NULL DEFAULT '[]'`
 ];
 // src/lib/session-apply.ts
-import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID4 } from "crypto";
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync4,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readdirSync,
-  statSync as statSync3
+  statSync as statSync4
 } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join7, parse as parse3, relative as relative3, resolve as resolve4 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute3, join as join8, parse as parse4, relative as relative4, resolve as resolve4 } from "path";
 class SessionApplyError extends Error {
   constructor(message) {
     super(message);
@@ -9947,13 +10223,13 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   };
 }
 function ensureSessionTargetHome(targetHome) {
-  if (!existsSync8(targetHome))
+  if (!existsSync9(targetHome))
     mkdirSync4(targetHome, { recursive: true, mode: 448 });
   assertSafeTargetHome(targetHome);
 }
 function checkSessionRenderDrift(targetHome, manifestPath) {
   const safeTargetHome = assertSafeTargetHome(targetHome);
-  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative3(safeTargetHome, resolve4(manifestPath)), safeTargetHome) : resolve4(safeTargetHome, ".hasna", "session-render-manifest.json");
+  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative4(safeTargetHome, resolve4(manifestPath)), safeTargetHome) : resolve4(safeTargetHome, ".hasna", "session-render-manifest.json");
   const checkedAt = new Date().toISOString();
   const previousManifest = readPreviousManifest(resolvedManifestPath);
   if (!previousManifest) {
@@ -9970,7 +10246,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
   const drifted = [];
   for (const file of previousManifest.files) {
     const target = resolveManifestRelativePath(file.relativePath, safeTargetHome);
-    if (!existsSync8(target)) {
+    if (!existsSync9(target)) {
       missing.push({
         path: target,
         relativePath: file.relativePath,
@@ -9980,7 +10256,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
       });
       continue;
     }
-    const actualSha256 = sha2563(readFileSync6(target, "utf-8"));
+    const actualSha256 = sha2564(readFileSync7(target, "utf-8"));
     if (actualSha256 !== file.sha256) {
       drifted.push({
         path: target,
@@ -10004,7 +10280,7 @@ function restoreSessionRenderSnapshot(snapshotPath, options = {}) {
   const snapshot = readSessionRenderSnapshot(snapshotPath);
   const targetHome = assertSafeTargetHome(snapshot.targetHome);
   const resolvedSnapshotPath = resolve4(snapshotPath);
-  const snapshotRelativePath = relative3(targetHome, resolvedSnapshotPath);
+  const snapshotRelativePath = relative4(targetHome, resolvedSnapshotPath);
   if (snapshotRelativePath === "" || snapshotRelativePath === ".." || snapshotRelativePath.startsWith("../") || isAbsolute3(snapshotRelativePath)) {
     throw new SessionApplyError("Session snapshot must be stored inside its target home.");
   }
@@ -10122,18 +10398,18 @@ function requiredRestoreHash(file) {
 }
 function readSessionRenderSnapshot(snapshotPath) {
   const resolved = resolve4(snapshotPath);
-  if (!existsSync8(resolved))
+  if (!existsSync9(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 (statSync3(resolved).size > 32 * 1024 * 1024) {
+  if (statSync4(resolved).size > 32 * 1024 * 1024) {
     throw new SessionApplyError(`Session snapshot exceeds the 32 MiB restore limit: ${snapshotPath}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync6(resolved, "utf8"));
+    parsed = JSON.parse(readFileSync7(resolved, "utf8"));
   } catch {
     throw new SessionApplyError(`Session snapshot is not valid JSON: ${snapshotPath}`);
   }
@@ -10155,7 +10431,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);
@@ -10203,7 +10479,7 @@ function readSessionRenderSnapshot(snapshotPath) {
 function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previousManifestFiles, targetHome, snapshotPath) {
   assertNoNewerSessionSnapshot(snapshotPath, snapshot.createdAt, targetHome);
   const manifestPath = resolve4(snapshot.manifestPath);
-  const manifestRelativePath = relative3(targetHome, manifestPath).replaceAll("\\", "/");
+  const manifestRelativePath = relative4(targetHome, manifestPath).replaceAll("\\", "/");
   resolveSnapshotFilePath(manifestRelativePath, snapshot.manifestPath, targetHome);
   const manifestSha256 = currentSessionFileHash(manifestPath, targetHome);
   if (manifestSha256 === null) {
@@ -10211,7 +10487,7 @@ function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previou
   }
   let parsedManifest;
   try {
-    parsedManifest = JSON.parse(readFileSync6(manifestPath, "utf8"));
+    parsedManifest = JSON.parse(readFileSync7(manifestPath, "utf8"));
   } catch {
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest is not valid JSON: ${snapshotPath}`);
   }
@@ -10303,15 +10579,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 readdirSync(dirname5(snapshotPath))) {
-    const candidatePath = resolve4(dirname5(snapshotPath), entry);
+  for (const entry of readdirSync(dirname6(snapshotPath))) {
+    const candidatePath = resolve4(dirname6(snapshotPath), entry);
     if (candidatePath === resolve4(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(readFileSync6(candidatePath, "utf8"));
+      const candidate = JSON.parse(readFileSync7(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" && resolve4(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}`);
@@ -10371,7 +10647,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}`);
@@ -10389,8 +10665,8 @@ function resolveSnapshotFilePath(relativePath, recordedPath, targetHome) {
 }
 function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options) {
   const target = resolvePlannedFilePath(plan, file, targetHome);
-  const previousContent = existsSync8(target) ? readFileSync6(target, "utf-8") : null;
-  const previousSha256 = previousContent === null ? null : sha2563(previousContent);
+  const previousContent = existsSync9(target) ? readFileSync7(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) {
@@ -10472,10 +10748,10 @@ function planStaleFileResults(plan, targetHome, previousManifest, currentRelativ
 }
 function planStaleFileResult(file, targetHome, options) {
   const target = resolveManifestRelativePath(file.relativePath, targetHome);
-  if (!existsSync8(target))
+  if (!existsSync9(target))
     return null;
-  const previousContent = readFileSync6(target, "utf-8");
-  const previousSha256 = sha2563(previousContent);
+  const previousContent = readFileSync7(target, "utf-8");
+  const previousSha256 = sha2564(previousContent);
   if (!options.force && previousSha256 !== file.sha256) {
     return {
       path: target,
@@ -10520,7 +10796,7 @@ function isPreviouslyManaged(file, previousSha256, previousHashes, previousManif
 }
 function resolvePlannedFilePath(plan, file, targetHome) {
   const target = resolve4(targetHome, ...file.relativePath.split("/"));
-  const rel = relative3(targetHome, target);
+  const rel = relative4(targetHome, target);
   if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute3(rel)) {
     throw new SessionApplyError(`Session file escapes target home: ${file.relativePath}`);
   }
@@ -10532,7 +10808,7 @@ function resolvePlannedFilePath(plan, file, targetHome) {
 }
 function resolveManifestRelativePath(relativePath, targetHome) {
   const target = resolve4(targetHome, ...relativePath.split(/[\\/]+/));
-  const rel = relative3(targetHome, target);
+  const rel = relative4(targetHome, target);
   if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute3(rel)) {
     throw new SessionApplyError(`Session manifest file escapes target home: ${relativePath}`);
   }
@@ -10540,10 +10816,10 @@ function resolveManifestRelativePath(relativePath, targetHome) {
   return target;
 }
 function readPreviousManifest(path) {
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(path, "utf-8"));
     if (parsed.schema !== SESSION_RENDER_SCHEMA)
       return null;
     if (!Array.isArray(parsed.files))
@@ -10577,18 +10853,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: ${relative3(targetHome, path)}`);
+    throw new SessionApplyError(`Session apply path changed after planning: ${relative4(targetHome, path)}`);
   }
 }
 function currentSessionFileHash(path, targetHome) {
   assertNoSymlinkSegments2(targetHome, path);
-  if (!existsSync8(path))
+  if (!existsSync9(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(readFileSync6(path, "utf-8"));
+  return sha2564(readFileSync7(path, "utf-8"));
 }
 function requiredPreviousHash(result) {
   if (result.previousSha256 === null) {
@@ -10597,13 +10873,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) => existsSync8(result.path)).map((result) => {
-    const content = readFileSync6(result.path, "utf-8");
+  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").filter((result) => existsSync9(result.path)).map((result) => {
+    const content = readFileSync7(result.path, "utf-8");
     return {
       path: result.path,
       relativePath: result.relativePath,
       role: result.role,
-      sha256: sha2563(content),
+      sha256: sha2564(content),
       content
     };
   });
@@ -10654,42 +10930,42 @@ function assertSafeTargetHome(targetHome) {
   if (!isAbsolute3(targetHome))
     throw new SessionApplyError(`Session target home must be absolute: ${targetHome}`);
   const normalized = resolve4(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 (existsSync8(normalized) && lstatSync2(normalized).isSymbolicLink()) {
+  if (existsSync9(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 = relative3(root, target);
+  const rel = relative4(root, target);
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join7(current, segment);
-    if (existsSync8(current) && lstatSync2(current).isSymbolicLink()) {
+    current = join8(current, segment);
+    if (existsSync9(current) && lstatSync2(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink: ${current}`);
     }
   }
 }
 function assertNoSymlinkAncestors2(path) {
   const normalized = resolve4(path);
-  const parsed = parse3(normalized);
+  const parsed = parse4(normalized);
   let current = parsed.root;
-  const rel = relative3(parsed.root, normalized);
+  const rel = relative4(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join7(current, segment);
-    if (!existsSync8(current))
+    current = join8(current, segment);
+    if (!existsSync9(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/lib/project-dashboard-standard.ts
 var PROJECT_DASHBOARD_STANDARD_SLUG = "agent-managed-project-dashboard-standard";
@@ -10987,12 +11263,12 @@ async function ensureDangerousOperationGuardStandardConfig(store = resolveConfig
   }
 }
 // src/lib/sync.ts
-import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
-import { basename as basename5, extname as extname3, join as join9 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
+import { basename as basename5, extname as extname3, join as join10 } from "path";
 
 // src/lib/sync-dir.ts
-import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync7, statSync as statSync4 } from "fs";
-import { join as join8, relative as relative4 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { join as join9, relative as relative5 } from "path";
 import { homedir as homedir4 } from "os";
 var SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
 function shouldSkip(p) {
@@ -11001,9 +11277,9 @@ function shouldSkip(p) {
 async function syncFromDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const absDir = expandPath(dir);
-  if (!existsSync9(absDir))
+  if (!existsSync10(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join8(absDir, f)).filter((f) => statSync4(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join9(absDir, f)).filter((f) => statSync5(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
   const home = homedir4();
   const allConfigs = await store.listConfigs();
@@ -11013,7 +11289,7 @@ async function syncFromDir(dir, opts = {}) {
       continue;
     }
     try {
-      const content = readFileSync7(file, "utf-8");
+      const content = readFileSync8(file, "utf-8");
       if (content.length > 500000) {
         result.skipped.push(file + " (too large)");
         continue;
@@ -11022,7 +11298,7 @@ async function syncFromDir(dir, opts = {}) {
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative4(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
+          await store.createConfig({ name: relative5(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)
@@ -11063,7 +11339,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const full = join8(dir, entry.name);
+    const full = join9(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -11115,7 +11391,7 @@ function isGeneratedOutputTarget2(config, owners) {
   return !!ownerIds && !ownerIds.has(config.id);
 }
 function hasClaudePromptSource() {
-  return existsSync10(expandPath("~/.claude/CLAUDE.md"));
+  return existsSync11(expandPath("~/.claude/CLAUDE.md"));
 }
 function hasClaudeRuleSourceForCursorTarget(targetPath) {
   const absoluteTargetPath = expandPath(targetPath);
@@ -11123,7 +11399,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
   const stem = basename5(absoluteTargetPath, ".mdc");
-  return existsSync10(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync10(expandPath(`~/.claude/rules/${stem}.mdc`));
+  return existsSync11(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync11(expandPath(`~/.claude/rules/${stem}.mdc`));
 }
 function isKnownGeneratedTargetPath(targetPath) {
   const normalizedTargetPath = normalizeTargetPath(targetPath);
@@ -11186,11 +11462,11 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join9(absDir, pf.file);
-    if (!existsSync10(abs))
+    const abs = join10(absDir, pf.file);
+    if (!existsSync11(abs))
       continue;
     try {
-      const rawContent = readFileSync8(abs, "utf-8");
+      const rawContent = readFileSync9(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(pf.file);
         continue;
@@ -11219,15 +11495,15 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join9(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join9(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" }
+    { dir: join10(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join10(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" }
   ]) {
-    if (!existsSync10(ruleDir.dir))
+    if (!existsSync11(ruleDir.dir))
       continue;
     const mdFiles = readdirSync3(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join9(ruleDir.dir, f);
-      const raw = readFileSync8(abs, "utf-8");
+      const abs = join10(ruleDir.dir, f);
+      const raw = readFileSync9(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
@@ -11266,20 +11542,20 @@ async function syncKnown(opts = {}) {
   for (const known of targets) {
     if (known.rulesDir) {
       const absDir = expandPath(known.rulesDir);
-      if (!existsSync10(absDir)) {
+      if (!existsSync11(absDir)) {
         result.skipped.push(known.rulesDir);
         continue;
       }
       const extensions = known.rulesExtensions ?? [".md", ".mdc"];
       const ruleFiles = readdirSync3(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join9(absDir, f);
+        const abs2 = join10(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
           continue;
         }
-        const raw = readFileSync8(abs2, "utf-8");
+        const raw = readFileSync9(abs2, "utf-8");
         const redacted = redactContent(raw, "markdown");
         const machineAware = templateizeMachineContent(redacted.content, machine);
         const content = machineAware.content;
@@ -11307,12 +11583,12 @@ async function syncKnown(opts = {}) {
       continue;
     }
     const abs = expandPath(known.path);
-    if (!existsSync10(abs)) {
+    if (!existsSync11(abs)) {
       result.skipped.push(known.path);
       continue;
     }
     try {
-      const rawContent = readFileSync8(abs, "utf-8");
+      const rawContent = readFileSync9(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(known.path + " (too large)");
         continue;
@@ -11400,9 +11676,9 @@ async function syncToDisk(opts = {}) {
 }
 function buildDiff(expectedContent, targetPath) {
   const path = expandPath(targetPath);
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return `(file not found on disk: ${path})`;
-  const diskContent = readFileSync8(path, "utf-8");
+  const diskContent = readFileSync9(path, "utf-8");
   if (diskContent === expectedContent)
     return "(no diff \u2014 identical)";
   const stored = expectedContent.split(`
@@ -11516,15 +11792,15 @@ function detectFormat(filePath) {
   return "text";
 }
 // src/lib/export.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join10, resolve as resolve5 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join11, resolve as resolve5 } 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 = resolve5(outputPath);
-  const tmpDir = join10(tmpdir(), `configs-export-${Date.now()}`);
-  const contentsDir = join10(tmpDir, "contents");
+  const tmpDir = join11(tmpdir(), `configs-export-${Date.now()}`);
+  const contentsDir = join11(tmpDir, "contents");
   try {
     mkdirSync5(contentsDir, { recursive: true });
     const manifest = {
@@ -11532,10 +11808,10 @@ async function exportConfigs(outputPath, opts = {}) {
       exported_at: new Date().toISOString(),
       configs: configs.map(({ content: _content, ...meta }) => meta)
     };
-    writeFileSync3(join10(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+    writeFileSync3(join11(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(join10(contentsDir, fileName), config.content, "utf-8");
+      writeFileSync3(join11(contentsDir, fileName), config.content, "utf-8");
     }
     const proc = Bun.spawn(["tar", "czf", absOutput, "-C", tmpDir, "."], {
       stdout: "pipe",
@@ -11548,20 +11824,20 @@ async function exportConfigs(outputPath, opts = {}) {
     }
     return { path: absOutput, count: configs.length };
   } finally {
-    if (existsSync11(tmpDir)) {
+    if (existsSync12(tmpDir)) {
       rmSync3(tmpDir, { recursive: true, force: true });
     }
   }
 }
 // src/lib/import.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync9, rmSync as rmSync4 } from "fs";
-import { join as join11, resolve as resolve6 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync4 } from "fs";
+import { join as join12, resolve as resolve6 } 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 = resolve6(bundlePath);
-  const tmpDir = join11(tmpdir2(), `configs-import-${Date.now()}`);
+  const tmpDir = join12(tmpdir2(), `configs-import-${Date.now()}`);
   const result = { created: 0, updated: 0, skipped: 0, errors: [] };
   try {
     mkdirSync6(tmpDir, { recursive: true });
@@ -11574,15 +11850,15 @@ async function importConfigs(bundlePath, opts = {}) {
       const stderr = await new Response(proc.stderr).text();
       throw new Error(`tar extraction failed: ${stderr}`);
     }
-    const manifestPath = join11(tmpDir, "manifest.json");
-    if (!existsSync12(manifestPath))
+    const manifestPath = join12(tmpDir, "manifest.json");
+    if (!existsSync13(manifestPath))
       throw new Error("Invalid bundle: missing manifest.json");
-    const manifest = JSON.parse(readFileSync9(manifestPath, "utf-8"));
+    const manifest = JSON.parse(readFileSync10(manifestPath, "utf-8"));
     for (const meta of manifest.configs) {
       try {
         const ext = meta.format === "text" ? "txt" : meta.format;
-        const contentFile = join11(tmpDir, "contents", `${meta.slug}.${ext}`);
-        const content = existsSync12(contentFile) ? readFileSync9(contentFile, "utf-8") : "";
+        const contentFile = join12(tmpDir, "contents", `${meta.slug}.${ext}`);
+        const content = existsSync13(contentFile) ? readFileSync10(contentFile, "utf-8") : "";
         let existing = null;
         try {
           existing = await store.getConfig(meta.slug);
@@ -11616,16 +11892,16 @@ async function importConfigs(bundlePath, opts = {}) {
     }
     return result;
   } finally {
-    if (existsSync12(tmpDir)) {
+    if (existsSync13(tmpDir)) {
       rmSync4(tmpDir, { recursive: true, force: true });
     }
   }
 }
 // src/lib/package-manager-guard.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync13, lstatSync as lstatSync3, readdirSync as readdirSync4, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync14, lstatSync as lstatSync3, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "fs";
 import { homedir as homedir5 } from "os";
-import { basename as basename6, dirname as dirname6, isAbsolute as isAbsolute4, join as join12, relative as relative5, resolve as resolve7 } from "path";
+import { basename as basename6, dirname as dirname7, isAbsolute as isAbsolute4, join as join13, relative as relative6, resolve as resolve7 } from "path";
 var SKIP_DIRS = new Set([
   ".git",
   "node_modules",
@@ -11667,7 +11943,7 @@ function scanPackageManagerSecrets(options = {}) {
   const findings = [];
   let scannedFiles = 0;
   for (const root of roots) {
-    if (!existsSync13(root))
+    if (!existsSync14(root))
       continue;
     const stat = lstatSync3(root);
     if (stat.isFile()) {
@@ -11677,14 +11953,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)
@@ -11696,8 +11972,8 @@ function scanPackageManagerSecrets(options = {}) {
   if (options.includeHome) {
     const home = homedir5();
     for (const name of HOME_FILES) {
-      const file = join12(home, name);
-      if (!existsSync13(file))
+      const file = join13(home, name);
+      if (!existsSync14(file))
         continue;
       const text = readTextFile(file);
       if (text === null)
@@ -11721,12 +11997,12 @@ function collectRepoFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
           continue;
-        visit(join12(dir, entry.name));
+        visit(join13(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const file = join12(dir, entry.name);
+      const file = join13(dir, entry.name);
       if (shouldScanRepoFile(file))
         out.push(file);
     }
@@ -11764,7 +12040,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");
@@ -11964,11 +12240,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"]
     });
@@ -11996,11 +12272,11 @@ function stripInlineComment(value) {
 function displayPath(file, root) {
   const home = homedir5();
   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) {
@@ -12029,6 +12305,7 @@ export {
   resolveProfileVariables,
   resolveConfigStore,
   resolveCloudConfig,
+  resolveAgentOperatingRulesPayload,
   renderTemplatePreview,
   renderTemplate,
   renderMachineAwareContentPreview,
@@ -12039,6 +12316,7 @@ export {
   planProjectContext,
   parseTemplateVars,
   parseProjectContextBundle,
+  parseAgentOperatingRulesVersion,
   now,
   normalizeOsFamily,
   machineContextToVariables,
@@ -12063,6 +12341,7 @@ export {
   currentHostname2 as currentHostname,
   currentArch2 as currentArch,
   computeProjectContextSourceHash,
+  compareAgentOperatingRulesVersions,
   cleanSessionPathInput,
   checkSessionRenderDrift,
   buildOpenCodeAgentsMd,
@@ -12118,5 +12397,7 @@ export {
   CONFIG_FORMATS,
   CONFIG_CATEGORIES,
   CONFIG_AGENTS,
-  CODEWITH_NATIVE_IMPORTS_ENV
+  CODEWITH_NATIVE_IMPORTS_ENV,
+  AGENT_OPERATING_RULES_SENTINEL_PATTERN,
+  AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY
 };