@hasna/instructions 0.5.2 → 0.5.4

package/dist/cli/index.js

@@ -2160,19 +2160,122 @@ var init_retired_storage_mode = __esm(() => {
   ];
 });
 
-// src/lib/raw-store-root.ts
+// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
 import { homedir as homedir2 } from "os";
-import { join as join2, resolve } from "path";
-function getRawStoreRoot() {
-  return resolve(process.env[RAW_STORE_ROOT_ENV] || join2(process.env["HOME"] || homedir2(), ".hasna", "instructions"));
+import { join as join2 } from "path";
+function assertApp(app) {
+  if (typeof app !== "string" || app.length === 0) {
+    throw new TypeError("paths: app must be a non-empty string");
+  }
+  if (!APP_SLUG_RE.test(app)) {
+    throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
+  }
+}
+function envOf(options) {
+  return options.env ?? process.env;
+}
+function envValue(options, kind) {
+  const value = envOf(options)[KIND_ENV[kind]];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function isMacOS(platform) {
+  return platform === "darwin";
+}
+function baseDir(kind, options) {
+  const override = envValue(options, kind);
+  if (override)
+    return override;
+  const home = options.home ?? homedir2();
+  const platform = options.platform ?? process.platform;
+  if (isMacOS(platform)) {
+    switch (kind) {
+      case "config":
+      case "data":
+        return join2(home, "Library", "Application Support", "Hasna");
+      case "cache":
+        return join2(home, "Library", "Caches", "Hasna");
+      case "state":
+        return join2(home, "Library", "Logs", "Hasna");
+    }
+  }
+  switch (kind) {
+    case "config":
+      return join2(home, ".config", "hasna");
+    case "data":
+      return join2(home, ".local", "share", "hasna");
+    case "state":
+      return join2(home, ".local", "state", "hasna");
+    case "cache":
+      return join2(home, ".cache", "hasna");
+  }
+}
+function resolvePath(kind, options) {
+  assertApp(options.app);
+  const appSegment = options.internal === true ? join2("internal", options.app) : options.app;
+  return join2(baseDir(kind, options), appSegment);
+}
+function configDir(options) {
+  return resolvePath("config", options);
+}
+var KIND_ENV, APP_SLUG_RE;
+var init_dist = __esm(() => {
+  KIND_ENV = {
+    config: "HASNA_CONFIG_HOME",
+    data: "HASNA_DATA_HOME",
+    state: "HASNA_STATE_HOME",
+    cache: "HASNA_CACHE_HOME"
+  };
+  APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+});
+
+// src/lib/app-home.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3, resolve } from "path";
+function homeDir(env = process.env) {
+  return env["HOME"] || env["USERPROFILE"] || homedir3();
+}
+function legacyStoreHome(env = process.env) {
+  return resolve(join3(homeDir(env), ".hasna", "instructions"));
+}
+function resolverStoreHome(env = process.env) {
+  return configDir({ app: "configs", env, home: env.HOME || env.USERPROFILE || homedir3() });
+}
+function adoptResolverStoreHome(resolved, env = process.env) {
+  const override = env.HASNA_CONFIG_HOME;
+  if (typeof override === "string" && override.trim().length > 0)
+    return true;
+  return existsSync2(join3(resolved, "instructions.db"));
+}
+function exactStoreHome(env = process.env) {
+  const v = env[HASNA_CONFIGS_HOME_ENV];
+  return v && v.trim() ? v.trim() : undefined;
+}
+function getConfigsStoreHome(env = process.env) {
+  const exact = exactStoreHome(env);
+  if (exact)
+    return resolve(exact);
+  const resolved = resolverStoreHome(env);
+  return adoptResolverStoreHome(resolved, env) ? resolve(resolved) : legacyStoreHome(env);
+}
+var HASNA_CONFIGS_HOME_ENV = "HASNA_CONFIGS_HOME";
+var init_app_home = __esm(() => {
+  init_dist();
+});
+
+// src/lib/raw-store-root.ts
+import { resolve as resolve2 } from "path";
+function getRawStoreRoot(env = process.env) {
+  return resolve2(getConfigsStoreHome(env));
 }
-var RAW_STORE_ROOT_ENV = "HASNA_CONFIGS_HOME";
-var init_raw_store_root = () => {};
+var init_raw_store_root = __esm(() => {
+  init_app_home();
+});
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync2, mkdirSync, rmSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync, rmSync } from "fs";
+import { join as join4 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function getDbPath() {
   if (process.env["HASNA_INSTRUCTIONS_DB_PATH"]) {
@@ -2180,7 +2283,7 @@ function getDbPath() {
   }
   const dir = getRawStoreRoot();
   mkdirSync(dir, { recursive: true });
-  return join3(dir, "instructions.db");
+  return join4(dir, "instructions.db");
 }
 function uuid() {
   return randomUUID3();
@@ -2221,7 +2324,7 @@ function resetLocalDatabase() {
   if (dbPath === ":memory:")
     return;
   for (const p of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (existsSync2(p))
+    if (existsSync3(p))
       rmSync(p);
   }
 }
@@ -2658,9 +2761,9 @@ var init_template = __esm(() => {
 });
 
 // src/lib/machine.ts
-import { arch as currentArch, homedir as homedir3, hostname as currentHostname, type as currentOsType } from "os";
-import { existsSync as existsSync3 } from "fs";
-import { join as join4 } from "path";
+import { arch as currentArch, homedir as homedir4, hostname as currentHostname, type as currentOsType } from "os";
+import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
 function normalizeOsFamily(os) {
   const value = (os ?? "").trim().toLowerCase();
   if (value === "darwin" || value === "macos" || value === "mac" || value === "osx")
@@ -2672,11 +2775,11 @@ function normalizeOsFamily(os) {
   return value || "unknown";
 }
 function detectMachineContext(overrides = {}) {
-  const homeDir = overrides.home_dir ?? process.env["CONFIGS_HOME"] ?? process.env["HOME"] ?? homedir3();
+  const homeDir2 = overrides.home_dir ?? process.env["CONFIGS_HOME"] ?? process.env["HOME"] ?? homedir4();
   const os = overrides.os ?? currentOsType();
   const osFamily = normalizeOsFamily(os);
-  const bunBinDir = overrides.bun_bin_dir ?? join4(homeDir, ".bun", "bin");
-  const defaultBunPath = osFamily === "macos" && existsSync3(BREW_BUN_PATH) ? BREW_BUN_PATH : join4(bunBinDir, "bun");
+  const bunBinDir = overrides.bun_bin_dir ?? join5(homeDir2, ".bun", "bin");
+  const defaultBunPath = osFamily === "macos" && existsSync4(BREW_BUN_PATH) ? BREW_BUN_PATH : join5(bunBinDir, "bun");
   return {
     id: "current-machine",
     hostname: overrides.hostname ?? currentHostname(),
@@ -2685,11 +2788,11 @@ function detectMachineContext(overrides = {}) {
     last_applied_at: null,
     created_at: "",
     os_family: osFamily,
-    home_dir: homeDir,
-    workspace_root: overrides.workspace_root ?? join4(homeDir, osFamily === "macos" ? "Workspace" : "workspace"),
+    home_dir: homeDir2,
+    workspace_root: overrides.workspace_root ?? join5(homeDir2, osFamily === "macos" ? "Workspace" : "workspace"),
     bun_bin_dir: bunBinDir,
     bun_path: overrides.bun_path ?? defaultBunPath,
-    path_prefix: overrides.path_prefix ?? (osFamily === "macos" ? `${join4("/opt", "homebrew", "bin")}:${bunBinDir}` : bunBinDir)
+    path_prefix: overrides.path_prefix ?? (osFamily === "macos" ? `${join5("/opt", "homebrew", "bin")}:${bunBinDir}` : bunBinDir)
   };
 }
 function machineContextToVariables(machine) {
@@ -7324,7 +7427,7 @@ import { dlopen, FFIType } from "bun:ffi";
 import {
   closeSync,
   constants,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   fstatSync,
   fsyncSync,
   lstatSync,
@@ -7337,7 +7440,7 @@ import {
   statSync,
   writeFileSync
 } from "fs";
-import { basename, dirname, isAbsolute, join as join5, parse, relative, resolve as resolve2 } from "path";
+import { basename, dirname, isAbsolute, join as join6, parse, relative, resolve as resolve3 } from "path";
 function managedObservationMaxBytes(relativePath) {
   return SESSION_MANAGED_OUTPUT_PATHS.includes(relativePath) ? SESSION_MANAGED_OUTPUT_MAX_BYTES : FOREIGN_INPUT_MAX_BYTES;
 }
@@ -7417,7 +7520,7 @@ function planProjectContext(input) {
   const inlineMarkerOverhead = nativeImports ? 0 : Buffer.byteLength(buildManagedBlock(bundle, "", `
 `), "utf8");
   const generated = buildCanonicalFragment(bundle, status, ageSeconds, PROJECT_CONTEXT_MAX_RENDERED_BYTES - Math.max(320, inlineMarkerOverhead), PROJECT_CONTEXT_MAX_APPROX_TOKENS - Math.max(80, Math.ceil(inlineMarkerOverhead / 4)));
-  const previousTargetContent = existsSync4(paths.target) ? readUtf8RegularFile(paths.target, workspaceRoot, managedObservationMaxBytes(relativePosix(workspaceRoot, paths.target))) : null;
+  const previousTargetContent = existsSync5(paths.target) ? readUtf8RegularFile(paths.target, workspaceRoot, managedObservationMaxBytes(relativePosix(workspaceRoot, paths.target))) : null;
   const markerParse = parseManagedBlock(previousTargetContent ?? "", input.force === true);
   if (markerParse.block && markerParse.block.id !== bundle.project.id) {
     throw new ProjectContextError("MANAGED_BLOCK_CONFLICT", "managed block belongs to a different project");
@@ -7468,7 +7571,7 @@ function composeProjectContextSessionRender(input) {
     return null;
   const { runtime, workspace_root: workspaceRoot, observed_hashes: observedHashes } = guard;
   const paths = runtimePaths(workspaceRoot, runtime);
-  if (!existsSync4(paths.manifest))
+  if (!existsSync5(paths.manifest))
     return null;
   assertCodewithTargetIsConsumed(workspaceRoot, runtime);
   const manifest = readProjectContextManifest(paths.manifest, workspaceRoot);
@@ -7497,7 +7600,7 @@ function composeProjectContextSessionRender(input) {
   }
   const fragment = readUtf8RegularFile(paths.fragment, workspaceRoot, PROJECT_CONTEXT_MAX_RENDERED_BYTES);
   scanGeneratedContent(fragment);
-  if (!existsSync4(paths.target)) {
+  if (!existsSync5(paths.target)) {
     throw new ProjectContextError("MANAGED_BLOCK_CONFLICT", "project-context provider target is missing while durable context is active");
   }
   const currentTarget = readUtf8RegularFile(paths.target, workspaceRoot, managedObservationMaxBytes(relativePosix(workspaceRoot, paths.target)));
@@ -7508,7 +7611,7 @@ function composeProjectContextSessionRender(input) {
   if (currentMarkers.block.id !== cache.project_id || currentMarkers.block.revision !== cache.revision || currentMarkers.block.hash !== cache.hash) {
     throw new ProjectContextError("MANAGED_BLOCK_CONFLICT", "project-context provider markers differ from the durable cache");
   }
-  const plannedIndexes = input.files.filter((file) => file.role === "index" && resolve2(file.path) === paths.target);
+  const plannedIndexes = input.files.filter((file) => file.role === "index" && resolve3(file.path) === paths.target);
   if (plannedIndexes.length !== 1) {
     throw new ProjectContextError("PROJECT_CONTEXT_MANIFEST_INVALID", "session renderer does not own the selected project-context provider target");
   }
@@ -7566,7 +7669,7 @@ function withProjectContextSessionGuard(guard, action, options = {}) {
     verify();
     return action(null);
   }
-  const lockPath = resolve2(validated.workspace_root, ...PROJECT_CONTEXT_LOCK_PATH.split("/"));
+  const lockPath = resolve3(validated.workspace_root, ...PROJECT_CONTEXT_LOCK_PATH.split("/"));
   const lock = acquireWorkspaceLock(validated.workspace_root, lockPath);
   try {
     verify();
@@ -7592,7 +7695,7 @@ function validateProjectContextSessionGuard(guard) {
     if (!isRecord(observed) || typeof observed.path !== "string") {
       throw new ProjectContextError("PROJECT_CONTEXT_SESSION_STALE", "session project-context guard contains malformed hash metadata");
     }
-    const path = resolve2(observed.path);
+    const path = resolve3(observed.path);
     if (!allowedPaths.has(path) || observedPaths.has(path)) {
       throw new ProjectContextError("PROJECT_CONTEXT_SESSION_STALE", "session project-context guard contains an unexpected or duplicate path");
     }
@@ -7614,7 +7717,7 @@ function validateProjectContextSessionGuard(guard) {
 function applyProjectContext(options) {
   const workspaceRoot = assertSafeWorkspaceRoot(options.workspace_root);
   const now3 = options.now ?? new Date;
-  const lockPath = resolve2(workspaceRoot, ...PROJECT_CONTEXT_LOCK_PATH.split("/"));
+  const lockPath = resolve3(workspaceRoot, ...PROJECT_CONTEXT_LOCK_PATH.split("/"));
   const lock = options.dry_run ? null : acquireWorkspaceLock(workspaceRoot, lockPath, options.test_hooks?.after_lock_open, options.test_hooks?.before_stale_lock_remove, options.test_hooks?.process_start_identity);
   try {
     const resolved = resolveBundleForApply(options, workspaceRoot, now3);
@@ -7761,7 +7864,7 @@ function resolveBundleForApply(options, workspaceRoot, now3) {
   if (!options.expected_project_id) {
     throw new ProjectContextError("PROJECT_CONTEXT_CACHE_ID_REQUIRED", "expected_project_id is required for stale-cache fallback");
   }
-  const cachePath = resolve2(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
+  const cachePath = resolve3(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
   const cache = readProjectContextCache(cachePath, workspaceRoot);
   if (!cache)
     throw new ProjectContextError("PROJECT_CONTEXT_CACHE_MISSING", "no last-known-good project context cache exists");
@@ -7963,7 +8066,7 @@ function findLegacyCodewithWorkspaceSection(workspaceRoot, runtime, content, bun
   if (runtime !== "codewith" || !content)
     return null;
   const sessionManifestPath = runtimePaths(workspaceRoot, runtime).sessionManifest;
-  if (!existsSync4(sessionManifestPath))
+  if (!existsSync5(sessionManifestPath))
     return null;
   const manifest = readSessionManifestRecord(sessionManifestPath, workspaceRoot);
   if (!manifest || manifest["schema"] !== SESSION_RENDER_SCHEMA) {
@@ -8014,7 +8117,7 @@ function assertRevisionOrdering(plan, force) {
   const manifest = readProjectContextManifest(plan.manifest_path, plan.workspace_root);
   if (manifest) {
     const manifestHashHasRecoveryProof = manifest.projectContext.hash === plan.bundle.hash || metadataSnapshotMatchesManifest(plan, manifest);
-    const canonicalStateAlreadyInstalled = cache !== null && canonicalCacheHash === plan.bundle.hash && cache.project_id === plan.bundle.project.id && cache.revision === plan.bundle.revision && plan.marker !== null && plan.marker.id === plan.bundle.project.id && plan.marker.revision === plan.bundle.revision && plan.marker.hash === plan.bundle.hash && existsSync4(plan.fragment_path) && fragmentMatchesBundle(plan.fragment_path, plan.bundle, plan.workspace_root) && manifestHashHasRecoveryProof;
+    const canonicalStateAlreadyInstalled = cache !== null && canonicalCacheHash === plan.bundle.hash && cache.project_id === plan.bundle.project.id && cache.revision === plan.bundle.revision && plan.marker !== null && plan.marker.id === plan.bundle.project.id && plan.marker.revision === plan.bundle.revision && plan.marker.hash === plan.bundle.hash && existsSync5(plan.fragment_path) && fragmentMatchesBundle(plan.fragment_path, plan.bundle, plan.workspace_root) && manifestHashHasRecoveryProof;
     observations.push({
       source: "manifest",
       id: manifest.projectContext.projectId,
@@ -8022,7 +8125,7 @@ function assertRevisionOrdering(plan, force) {
       hash: canonicalStateAlreadyInstalled && manifest.projectContext.projectId === plan.bundle.project.id && manifest.projectContext.revision === plan.bundle.revision ? plan.bundle.hash : normalizePersistedHash(manifest.projectContext.revision, manifest.projectContext.hash)
     });
     const fragmentEntry = manifest.files.find((file) => file.relativePath === PROJECT_CONTEXT_FRAGMENT_PATH);
-    if (fragmentEntry && existsSync4(plan.fragment_path)) {
+    if (fragmentEntry && existsSync5(plan.fragment_path)) {
       const actual = currentFileHash(plan.fragment_path, plan.workspace_root);
       if (actual !== fragmentEntry.sha256 && !fragmentMatchesBundle(plan.fragment_path, plan.bundle, plan.workspace_root) && !force) {
         throw new ProjectContextError("MANAGED_BLOCK_CONFLICT", "canonical project-context fragment changed outside Instructions");
@@ -8117,9 +8220,9 @@ function buildManifest(plan, now3) {
 function buildSessionCompatibilityManifest(plan, now3) {
   const paths = runtimePaths(plan.workspace_root, plan.runtime);
   const tool = manifestTool(plan.runtime);
-  const targetHome = plan.runtime === "codewith" ? resolve2(plan.workspace_root, ".codewith") : plan.workspace_root;
+  const targetHome = plan.runtime === "codewith" ? resolve3(plan.workspace_root, ".codewith") : plan.workspace_root;
   const targetRelativePath = sessionTargetRelativePath(plan.runtime);
-  const existing = existsSync4(paths.sessionManifest) ? readSessionManifestRecord(paths.sessionManifest, plan.workspace_root) : {
+  const existing = existsSync5(paths.sessionManifest) ? readSessionManifestRecord(paths.sessionManifest, plan.workspace_root) : {
     schema: SESSION_RENDER_SCHEMA,
     tool,
     adapterMode: plan.native_imports ? "native-imports" : "flattened-markdown",
@@ -8139,7 +8242,7 @@ function buildSessionCompatibilityManifest(plan, now3) {
     throw new ProjectContextError("PROJECT_CONTEXT_MANIFEST_INVALID", "provider session manifest is malformed or incompatible");
   }
   const existingTargetHome = safeLegacyMetadataString(existing["targetHome"], null);
-  if (existingTargetHome !== null && resolve2(existingTargetHome) !== targetHome) {
+  if (existingTargetHome !== null && resolve3(existingTargetHome) !== targetHome) {
     throw new ProjectContextError("PROJECT_CONTEXT_MANIFEST_INVALID", "provider session manifest targets a different workspace");
   }
   const sources = sanitizeLegacySources(existing["sources"]).filter((source) => source["id"] !== "project-context-bundle");
@@ -8425,9 +8528,9 @@ function writeMetadataSnapshot(plan, now3) {
   const previous = readProjectContextManifest(plan.manifest_path, plan.workspace_root);
   if (!previous || previous.projectContext.revision === plan.bundle.revision && previous.projectContext.hash === plan.bundle.hash)
     return null;
-  const snapshotDir = resolve2(plan.workspace_root, ...PROJECT_CONTEXT_SNAPSHOT_DIR.split("/"));
+  const snapshotDir = resolve3(plan.workspace_root, ...PROJECT_CONTEXT_SNAPSHOT_DIR.split("/"));
   ensureSafeDirectory(snapshotDir, plan.workspace_root, 448);
-  const snapshotPath = resolve2(snapshotDir, `${safeFilename(previous.projectContext.revision)}-${previous.projectContext.hash.slice(-12)}.json`);
+  const snapshotPath = resolve3(snapshotDir, `${safeFilename(previous.projectContext.revision)}-${previous.projectContext.hash.slice(-12)}.json`);
   const snapshot = {
     schema: "hasna.configs.session-render-snapshot/v1",
     kind: "project-context-metadata",
@@ -8443,9 +8546,9 @@ function writeMetadataSnapshot(plan, now3) {
   return snapshotPath;
 }
 function metadataSnapshotMatchesManifest(plan, manifest) {
-  const snapshotDir = resolve2(plan.workspace_root, ...PROJECT_CONTEXT_SNAPSHOT_DIR.split("/"));
-  const snapshotPath = resolve2(snapshotDir, `${safeFilename(manifest.projectContext.revision)}-${manifest.projectContext.hash.slice(-12)}.json`);
-  if (!existsSync4(snapshotPath))
+  const snapshotDir = resolve3(plan.workspace_root, ...PROJECT_CONTEXT_SNAPSHOT_DIR.split("/"));
+  const snapshotPath = resolve3(snapshotDir, `${safeFilename(manifest.projectContext.revision)}-${manifest.projectContext.hash.slice(-12)}.json`);
+  if (!existsSync5(snapshotPath))
     return false;
   const record = readJsonRecord(snapshotPath, plan.workspace_root);
   const result = projectContextMetadataSnapshotSchema.safeParse(record);
@@ -8493,10 +8596,10 @@ function writeProjectContextRollbackSnapshot(plan, now3, outputs) {
       sha256: nextHash
     };
   });
-  const snapshotDir = resolve2(plan.workspace_root, ...SESSION_RENDER_SNAPSHOT_RELATIVE_DIR.split("/"));
+  const snapshotDir = resolve3(plan.workspace_root, ...SESSION_RENDER_SNAPSHOT_RELATIVE_DIR.split("/"));
   ensureSafeDirectory(snapshotDir, plan.workspace_root, 448);
   const timestamp = now3.toISOString().replace(/[:.]/g, "-");
-  const snapshotPath = resolve2(snapshotDir, `${timestamp}-${randomUUID5()}.json`);
+  const snapshotPath = resolve3(snapshotDir, `${timestamp}-${randomUUID5()}.json`);
   const snapshot = {
     schema: "hasna.configs.session-render-snapshot/v2",
     createdAt: now3.toISOString(),
@@ -8514,7 +8617,7 @@ function writeProjectContextRollbackSnapshot(plan, now3, outputs) {
   return snapshotPath;
 }
 function readProjectContextManifest(path, workspaceRoot) {
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   const record = readJsonRecord(path, workspaceRoot);
   const result = storedManifestObservationSchema.safeParse(record);
@@ -8529,7 +8632,7 @@ function readProjectContextManifest(path, workspaceRoot) {
   };
 }
 function readProjectContextCache(path, workspaceRoot) {
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   const record = readJsonRecord(path, workspaceRoot);
   const result = projectContextCacheSchema.safeParse(record);
@@ -8561,7 +8664,7 @@ function readSessionManifestRecord(path, workspaceRoot) {
   }
 }
 function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash, afterExchange, atomicExchangeUnavailable = false, beforeInstall, portableCreateOnly = false, maxObservedBytes, allowPortableReplacement = false) {
-  const dir = resolve2(path, "..");
+  const dir = resolve3(path, "..");
   ensureSafeDirectory(dir, workspaceRoot, 448);
   assertNoSymlinkSegments(workspaceRoot, path);
   const anchoredOps = portableCreateOnly ? null : resolveAnchoredFsOps();
@@ -8578,7 +8681,7 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
   const previous = anchoredFileObservation(directory, targetName);
   const previousMode = previous?.mode ?? defaultMode;
   const tempName = `.project-context-${randomUUID5()}.tmp`;
-  const tempPath = join5(dir, tempName);
+  const tempPath = join6(dir, tempName);
   let fd = null;
   let preserveTemp = false;
   let directoryChanged = false;
@@ -8709,7 +8812,7 @@ function atomicWritePortable(path, content, workspaceRoot, defaultMode, expected
   }
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
-  const tempPath = join5(dir, `.project-context-${randomUUID5()}.tmp`);
+  const tempPath = join6(dir, `.project-context-${randomUUID5()}.tmp`);
   let fd = null;
   let tempIdentity = null;
   try {
@@ -8766,7 +8869,7 @@ function atomicWritePortableReplacement(path, content, workspaceRoot, expectedHa
   }
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
-  const tempPath = join5(dir, `.project-context-${randomUUID5()}.tmp`);
+  const tempPath = join6(dir, `.project-context-${randomUUID5()}.tmp`);
   const desiredHash = sha2562(content);
   let fd = null;
   let tempIdentity = null;
@@ -8823,7 +8926,7 @@ function portablePreparedHash(tempPath, path, workspaceRoot, maxObservedBytes, s
 function portableFileHash(path, workspaceRoot, maxObservedBytes) {
   if (maxObservedBytes === undefined)
     return currentFileHash(path, workspaceRoot);
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   assertNoSymlinkSegments(workspaceRoot, path);
   const stat = lstatSync(path);
@@ -8835,11 +8938,11 @@ function portableFileHash(path, workspaceRoot, maxObservedBytes) {
   return createHash2("sha256").update(readFileSync(path)).digest("hex");
 }
 function writeProjectContextCoordinatedFile(input) {
-  atomicWriteFile(resolve2(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);
+  atomicWriteFile(resolve3(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);
-  const path = resolve2(input.path);
+  const path = resolve3(input.path);
   assertNoSymlinkSegments(workspaceRoot, path);
   const dir = dirname(path);
   const anchoredOps = input.force_portable_file_ops ? null : resolveAnchoredFsOps();
@@ -8865,7 +8968,7 @@ function removeProjectContextCoordinatedFile(input) {
       throw new ProjectContextHashRace(`managed path changed during deletion: ${relativePosix(workspaceRoot, path)}`);
     }
     displaced = true;
-    input.test_hooks?.after_displace?.(join5(dir, displacedName));
+    input.test_hooks?.after_displace?.(join6(dir, displacedName));
     const moved = anchoredFileObservation(directory, displacedName);
     if (!moved || moved.dev !== observed.dev || moved.ino !== observed.ino || moved.hash !== input.expected_hash || anchoredFileObservation(directory, targetName) !== null) {
       throw new ProjectContextHashRace(`managed path changed during deletion validation: ${relativePosix(workspaceRoot, path)}`);
@@ -8911,7 +9014,7 @@ function removePortableCoordinatedFile(path, workspaceRoot, expectedHash, maxObs
   }
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
-  const displacedPath = join5(dir, `.project-context-delete-${randomUUID5()}.tmp`);
+  const displacedPath = join6(dir, `.project-context-delete-${randomUUID5()}.tmp`);
   let displaced = false;
   try {
     assertManagedDirectoryStable(dir, workspaceRoot, directoryIdentity);
@@ -8922,7 +9025,7 @@ function removePortableCoordinatedFile(path, workspaceRoot, expectedHash, maxObs
     displaced = true;
     afterDisplace?.(displacedPath);
     const moved = lstatSync(displacedPath);
-    if (moved.isSymbolicLink() || !moved.isFile() || moved.dev !== observed.dev || moved.ino !== observed.ino || portableFileHash(displacedPath, workspaceRoot, maxObservedBytes) !== expectedHash || existsSync4(path)) {
+    if (moved.isSymbolicLink() || !moved.isFile() || moved.dev !== observed.dev || moved.ino !== observed.ino || portableFileHash(displacedPath, workspaceRoot, maxObservedBytes) !== expectedHash || existsSync5(path)) {
       throw new ProjectContextHashRace(`managed path changed during portable deletion: ${relativePosix(workspaceRoot, path)}`);
     }
     rmSync2(displacedPath);
@@ -8982,7 +9085,7 @@ function anchoredOpenExclusive(directory, name, mode) {
   const requestedMode = mode & 4095;
   let fd;
   try {
-    fd = openSync(join5(directory.path, name), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, requestedMode);
+    fd = openSync(join6(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)}`);
   }
@@ -9025,7 +9128,7 @@ function anchoredFileObservation(directory, name) {
     const stat = fstatSync(fd);
     if (!stat.isFile())
       throw new ProjectContextHashRace("managed output is not a regular file");
-    const relativePath = relativePosix(directory.workspaceRoot, join5(directory.path, name));
+    const relativePath = relativePosix(directory.workspaceRoot, join6(directory.path, name));
     const maxBytes = directory.maxObservedBytes === undefined ? managedObservationMaxBytes(relativePath) : directory.maxObservedBytes;
     if (maxBytes !== null && stat.size > maxBytes) {
       throw new ProjectContextHashRace(`managed output exceeds the safe read limit: ${relativePath}`);
@@ -9051,7 +9154,7 @@ function anchoredPreparedObservation(directory, name, path, stage) {
   return observed;
 }
 function captureManagedDirectoryIdentity(path, workspaceRoot) {
-  assertNoSymlinkSegments(workspaceRoot, join5(path, ".project-context-directory-guard"));
+  assertNoSymlinkSegments(workspaceRoot, join6(path, ".project-context-directory-guard"));
   let stat;
   try {
     stat = lstatSync(path);
@@ -9064,7 +9167,7 @@ function captureManagedDirectoryIdentity(path, workspaceRoot) {
   return { dev: stat.dev, ino: stat.ino };
 }
 function assertManagedDirectoryStable(path, workspaceRoot, expected) {
-  assertNoSymlinkSegments(workspaceRoot, join5(path, ".project-context-directory-guard"));
+  assertNoSymlinkSegments(workspaceRoot, join6(path, ".project-context-directory-guard"));
   let current;
   try {
     current = lstatSync(path);
@@ -9197,10 +9300,10 @@ function resolveAnchoredFsOps() {
   return null;
 }
 function acquireWorkspaceLock(workspaceRoot, lockPath, afterOpen, beforeStaleRemove, processStartIdentityLookup = processStartIdentity) {
-  const lockDirectory = resolve2(lockPath, "..");
+  const lockDirectory = resolve3(lockPath, "..");
   ensureSafeDirectory(lockDirectory, workspaceRoot, 448);
   assertNoSymlinkSegments(workspaceRoot, lockPath);
-  const tempPath = join5(lockDirectory, `.project-context-lock-${randomUUID5()}.tmp`);
+  const tempPath = join6(lockDirectory, `.project-context-lock-${randomUUID5()}.tmp`);
   let fd = null;
   let openedIdentity = null;
   let openedContentHash = null;
@@ -9234,7 +9337,7 @@ function acquireWorkspaceLock(workspaceRoot, lockPath, afterOpen, beforeStaleRem
       linked = true;
     }
     fsyncDirectory(lockDirectory);
-    if (existsSync4(tempPath)) {
+    if (existsSync5(tempPath)) {
       rmSync2(tempPath);
       fsyncDirectory(lockDirectory);
     }
@@ -9249,7 +9352,7 @@ function acquireWorkspaceLock(workspaceRoot, lockPath, afterOpen, beforeStaleRem
     if (linked && openedIdentity && openedContentHash) {
       removeOwnedLockByInode(lockPath, openedIdentity, openedContentHash);
     }
-    if (!preserveTemp && existsSync4(tempPath)) {
+    if (!preserveTemp && existsSync5(tempPath)) {
       try {
         rmSync2(tempPath);
       } catch {}
@@ -9264,7 +9367,7 @@ function acquireWorkspaceLock(workspaceRoot, lockPath, afterOpen, beforeStaleRem
 }
 function removeOwnedLockByInode(lockPath, identity, expectedHash) {
   try {
-    if (!existsSync4(lockPath))
+    if (!existsSync5(lockPath))
       return;
     const current = lstatSync(lockPath);
     if (current.isSymbolicLink() || current.dev !== identity.dev || current.ino !== identity.ino)
@@ -9272,7 +9375,7 @@ function removeOwnedLockByInode(lockPath, identity, expectedHash) {
     if (expectedHash !== undefined && sha2562(readFileSync(lockPath, "utf8")) !== expectedHash)
       return;
     rmSync2(lockPath);
-    fsyncDirectory(resolve2(lockPath, ".."));
+    fsyncDirectory(resolve3(lockPath, ".."));
   } catch {}
 }
 function observeStaleWorkspaceLock(lockPath, workspaceRoot, processStartIdentityLookup = processStartIdentity) {
@@ -9343,7 +9446,7 @@ function tryTakeoverStaleWorkspaceLock(candidatePath, lockPath, workspaceRoot, c
     const candidateInstalled = !current.isSymbolicLink() && current.dev === candidateIdentity.dev && current.ino === candidateIdentity.ino && currentFileHash(lockPath, workspaceRoot) === candidateHash;
     const staleDisplaced = !displaced.isSymbolicLink() && displaced.dev === stale.identity.dev && displaced.ino === stale.identity.ino && currentFileHash(candidatePath, workspaceRoot) === stale.contentHash;
     if (!candidateInstalled || !staleDisplaced) {
-      if (candidateInstalled && existsSync4(candidatePath)) {
+      if (candidateInstalled && existsSync5(candidatePath)) {
         atomicExchangePaths(candidatePath, lockPath);
         exchanged = false;
         return false;
@@ -9351,13 +9454,13 @@ function tryTakeoverStaleWorkspaceLock(candidatePath, lockPath, workspaceRoot, c
       throw new ProjectContextError("PROJECT_CONTEXT_LOCK_LOST", "workspace lock changed during stale-lock takeover and could not be restored safely");
     }
     rmSync2(candidatePath);
-    fsyncDirectory(resolve2(lockPath, ".."));
+    fsyncDirectory(resolve3(lockPath, ".."));
     exchanged = false;
     return true;
   } catch (error) {
     if (exchanged) {
       try {
-        if (currentFileHash(lockPath, workspaceRoot) === candidateHash && existsSync4(candidatePath)) {
+        if (currentFileHash(lockPath, workspaceRoot) === candidateHash && existsSync5(candidatePath)) {
           atomicExchangePaths(candidatePath, lockPath);
           exchanged = false;
         }
@@ -9370,7 +9473,7 @@ function tryTakeoverStaleWorkspaceLock(candidatePath, lockPath, workspaceRoot, c
   }
 }
 function assertWorkspaceLockHeld(lockPath, lock, workspaceRoot) {
-  if (!existsSync4(lockPath)) {
+  if (!existsSync5(lockPath)) {
     throw new ProjectContextError("PROJECT_CONTEXT_LOCK_LOST", "workspace project-context lock changed during render");
   }
   const current = lstatSync(lockPath);
@@ -9430,8 +9533,8 @@ function releaseWorkspaceLock(lockPath, lock, workspaceRoot) {
     }
     return;
   }
-  const lockDirectory = resolve2(lockPath, "..");
-  const releasePath = join5(lockDirectory, `.project-context-release-${randomUUID5()}.tmp`);
+  const lockDirectory = resolve3(lockPath, "..");
+  const releasePath = join6(lockDirectory, `.project-context-release-${randomUUID5()}.tmp`);
   let releaseFd = null;
   let releaseIdentity = null;
   let releaseHash = null;
@@ -9460,7 +9563,7 @@ function releaseWorkspaceLock(lockPath, lock, workspaceRoot) {
     const releaseInstalled = !installed.isSymbolicLink() && installed.dev === releaseIdentity.dev && installed.ino === releaseIdentity.ino && currentFileHash(lockPath, workspaceRoot) === releaseHash;
     const ownedDisplaced = !displaced.isSymbolicLink() && displaced.dev === lock.identity.dev && displaced.ino === lock.identity.ino && currentFileHash(releasePath, workspaceRoot) === lock.contentHash;
     if (!releaseInstalled || !ownedDisplaced) {
-      if (releaseInstalled && existsSync4(releasePath)) {
+      if (releaseInstalled && existsSync5(releasePath)) {
         atomicExchangePaths(releasePath, lockPath);
         exchanged = false;
       }
@@ -9473,7 +9576,7 @@ function releaseWorkspaceLock(lockPath, lock, workspaceRoot) {
   } catch {
     if (exchanged) {
       try {
-        if (releaseHash && currentFileHash(lockPath, workspaceRoot) === releaseHash && existsSync4(releasePath)) {
+        if (releaseHash && currentFileHash(lockPath, workspaceRoot) === releaseHash && existsSync5(releasePath)) {
           atomicExchangePaths(releasePath, lockPath);
           exchanged = false;
         }
@@ -9485,7 +9588,7 @@ function releaseWorkspaceLock(lockPath, lock, workspaceRoot) {
         closeSync(releaseFd);
       } catch {}
     }
-    if (!exchanged && existsSync4(releasePath)) {
+    if (!exchanged && existsSync5(releasePath)) {
       try {
         rmSync2(releasePath);
       } catch {}
@@ -9511,15 +9614,15 @@ function ensureSafeDirectory(path, workspaceRoot, mode) {
   const segments = rel.split(/[\\/]+/).filter(Boolean);
   let current = workspaceRoot;
   for (const segment of segments) {
-    current = join5(current, segment);
-    if (existsSync4(current)) {
+    current = join6(current, segment);
+    if (existsSync5(current)) {
       if (lstatSync(current).isSymbolicLink())
         throw new ProjectContextError("PROJECT_CONTEXT_SYMLINK_REJECTED", `managed path uses a symlink: ${current}`);
       if (!statSync(current).isDirectory())
         throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", `managed path is not a directory: ${current}`);
     } else {
       mkdirSync2(current, { mode });
-      fsyncDirectory(resolve2(current, ".."));
+      fsyncDirectory(resolve3(current, ".."));
     }
   }
 }
@@ -9575,11 +9678,11 @@ function scanGeneratedContent(content) {
 function runtimePaths(workspaceRoot, runtime) {
   const relativeTarget = runtime === "claude" ? "CLAUDE.md" : runtime === "codewith" ? ".codewith/CODEWITH.md" : "AGENTS.md";
   return {
-    target: resolve2(workspaceRoot, ...relativeTarget.split("/")),
-    fragment: resolve2(workspaceRoot, ...PROJECT_CONTEXT_FRAGMENT_PATH.split("/")),
-    manifest: resolve2(workspaceRoot, ...PROJECT_CONTEXT_MANIFEST_PATH.split("/")),
-    cache: resolve2(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/")),
-    sessionManifest: runtime === "codewith" ? resolve2(workspaceRoot, ".codewith", ".hasna", "session-render-manifest.json") : resolve2(workspaceRoot, ".hasna", "session-render-manifest.json")
+    target: resolve3(workspaceRoot, ...relativeTarget.split("/")),
+    fragment: resolve3(workspaceRoot, ...PROJECT_CONTEXT_FRAGMENT_PATH.split("/")),
+    manifest: resolve3(workspaceRoot, ...PROJECT_CONTEXT_MANIFEST_PATH.split("/")),
+    cache: resolve3(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/")),
+    sessionManifest: runtime === "codewith" ? resolve3(workspaceRoot, ".codewith", ".hasna", "session-render-manifest.json") : resolve3(workspaceRoot, ".hasna", "session-render-manifest.json")
   };
 }
 function projectContextSessionGuardPaths(paths, runtime) {
@@ -9589,7 +9692,7 @@ function projectContextSessionGuardPaths(paths, runtime) {
     paths.fragment,
     paths.target,
     paths.sessionManifest,
-    ...runtime === "codewith" ? [resolve2(paths.target, "..", "CODEWITH.override.md")] : []
+    ...runtime === "codewith" ? [resolve3(paths.target, "..", "CODEWITH.override.md")] : []
   ];
 }
 function sessionTargetRelativePath(runtime) {
@@ -9609,27 +9712,27 @@ function projectContextRuntimeForSessionTool(tool) {
   return null;
 }
 function projectContextWorkspaceForSession(input, runtime) {
-  const targetHome = resolve2(input.target_home);
+  const targetHome = resolve3(input.target_home);
   if (runtime === "codewith") {
     const workspaceRoot = basename(targetHome) === ".codewith" ? dirname(targetHome) : null;
     if (!workspaceRoot)
       return null;
-    if (input.project_root && resolve2(input.project_root) !== workspaceRoot) {
+    if (input.project_root && resolve3(input.project_root) !== workspaceRoot) {
       throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", "Codewith project_root must be the parent workspace of target_home");
     }
-    if (!existsSync4(workspaceRoot) || !lstatSync(workspaceRoot).isDirectory())
+    if (!existsSync5(workspaceRoot) || !lstatSync(workspaceRoot).isDirectory())
       return null;
     return assertSafeWorkspaceRoot(workspaceRoot);
   }
-  if (!existsSync4(targetHome) || !lstatSync(targetHome).isDirectory())
+  if (!existsSync5(targetHome) || !lstatSync(targetHome).isDirectory())
     return null;
   return assertSafeWorkspaceRoot(targetHome);
 }
 function assertCodewithTargetIsConsumed(workspaceRoot, runtime) {
   if (runtime !== "codewith")
     return;
-  const override = resolve2(workspaceRoot, ".codewith", "CODEWITH.override.md");
-  if (!existsSync4(override))
+  const override = resolve3(workspaceRoot, ".codewith", "CODEWITH.override.md");
+  if (!existsSync5(override))
     return;
   assertNoSymlinkSegments(workspaceRoot, override);
   if (!lstatSync(override).isFile())
@@ -9639,10 +9742,10 @@ function assertCodewithTargetIsConsumed(workspaceRoot, runtime) {
 function assertSafeWorkspaceRoot(path) {
   if (!isAbsolute(path))
     throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", "workspace root must be absolute");
-  const normalized = resolve2(path);
+  const normalized = resolve3(path);
   if (normalized === parse(normalized).root)
     throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", "workspace root cannot be the filesystem root");
-  if (!existsSync4(normalized) || !lstatSync(normalized).isDirectory())
+  if (!existsSync5(normalized) || !lstatSync(normalized).isDirectory())
     throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", "workspace root must be an existing directory");
   assertNoSymlinkAncestors(normalized);
   if (lstatSync(normalized).isSymbolicLink())
@@ -9656,18 +9759,18 @@ function assertNoSymlinkSegments(root, target) {
   }
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join5(current, segment);
-    if (existsSync4(current) && lstatSync(current).isSymbolicLink()) {
+    current = join6(current, segment);
+    if (existsSync5(current) && lstatSync(current).isSymbolicLink()) {
       throw new ProjectContextError("PROJECT_CONTEXT_SYMLINK_REJECTED", `managed path uses a symlink: ${current}`);
     }
   }
 }
 function assertNoSymlinkAncestors(path) {
-  const normalized = resolve2(path);
+  const normalized = resolve3(path);
   let current = parse(normalized).root;
   for (const segment of relative(current, normalized).split(/[\\/]+/).filter(Boolean)) {
-    current = join5(current, segment);
-    if (!existsSync4(current))
+    current = join6(current, segment);
+    if (!existsSync5(current))
       return;
     if (lstatSync(current).isSymbolicLink())
       throw new ProjectContextError("PROJECT_CONTEXT_SYMLINK_REJECTED", `workspace ancestor is a symlink: ${current}`);
@@ -9683,7 +9786,7 @@ function readUtf8RegularFile(path, workspaceRoot, maxBytes = FOREIGN_INPUT_MAX_B
   return readFileSync(path, "utf8");
 }
 function currentFileHash(path, workspaceRoot) {
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   const relativePath = relativePosix(workspaceRoot, path);
   return sha2562(readUtf8RegularFile(path, workspaceRoot, managedObservationMaxBytes(relativePath)));
@@ -9702,10 +9805,10 @@ function fragmentMatchesBundle(path, bundle, workspaceRoot) {
 }
 function durableSourcePath(path, workspaceRoot) {
   if (!path || path.startsWith("/dev/fd/"))
-    return resolve2(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
-  const normalized = isAbsolute(path) ? resolve2(path) : resolve2(workspaceRoot, path);
+    return resolve3(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
+  const normalized = isAbsolute(path) ? resolve3(path) : resolve3(workspaceRoot, path);
   if (normalized.startsWith("/dev/fd/"))
-    return resolve2(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
+    return resolve3(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
   return normalized;
 }
 function compareRevisions(incoming, previous) {
@@ -10265,7 +10368,7 @@ function compareProviderVersions(left, right) {
 
 // src/lib/asset-plan.ts
 import { createHash as createHash3 } from "crypto";
-import { isAbsolute as isAbsolute2, posix, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, posix, resolve as resolve4 } from "path";
 function assetCapability(provider, surface, kind, support, strategies, note, providerVersionRange = "*") {
   return Object.freeze({
     schema: ASSET_CAPABILITY_SCHEMA,
@@ -10472,8 +10575,8 @@ function resolveAssetDestination(item, roots) {
   if (!isAbsolute2(root))
     throw new Error(`Asset ${item.assetKey} destination root must be absolute.`);
   const relativePath = safeRelativePath(item.destination.relativePath);
-  const target = resolve3(root, ...relativePath.split("/"));
-  const normalizedRoot = resolve3(root);
+  const target = resolve4(root, ...relativePath.split("/"));
+  const normalizedRoot = resolve4(root);
   if (target === normalizedRoot)
     throw new Error(`Asset ${item.assetKey} destination cannot replace its root.`);
   if (!target.startsWith(`${normalizedRoot}/`))
@@ -10653,13 +10756,13 @@ var init_asset_plan = __esm(() => {
 // src/lib/cursor-authority.ts
 import { createHash as createHash4 } from "crypto";
 import { lstatSync as lstatSync2, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join6, resolve as resolve4 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join7, resolve as resolve5 } from "path";
 function sha2564(content) {
   return createHash4("sha256").update(content).digest("hex");
 }
-function homeDir() {
-  return process.env["HOME"] || homedir4();
+function homeDir2() {
+  return process.env["HOME"] || homedir5();
 }
 function markerPayload(content, markerLine, markerIndex) {
   const index = markerIndex ?? content.indexOf(markerLine);
@@ -10675,12 +10778,12 @@ function baseObservation(path) {
   };
 }
 function observeCursorGlobalAuthority(options = {}) {
-  const authorityPath = resolve4(join6(options.home ?? homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
+  const authorityPath = resolve5(join7(options.home ?? homeDir2(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
   const readFile2 = options.readFile ?? ((path) => readFileSync2(path, "utf8"));
   return observeCursorGlobalAuthorityPath(authorityPath, readFile2);
 }
 function observeCursorGlobalAuthorityAtPath(authorityPath) {
-  return observeCursorGlobalAuthorityPath(resolve4(authorityPath), (path) => readFileSync2(path, "utf8"));
+  return observeCursorGlobalAuthorityPath(resolve5(authorityPath), (path) => readFileSync2(path, "utf8"));
 }
 function observeCursorGlobalAuthorityPath(authorityPath, readFile2) {
   const base = baseObservation(authorityPath);
@@ -10825,11 +10928,21 @@ function observeCursorGlobalAuthorityPath(authorityPath, readFile2) {
   };
 }
 function isCursorGlobalAuthorityPath(path) {
-  return resolve4(path) === resolve4(join6(homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
+  return resolve5(path) === resolve5(join7(homeDir2(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
 }
 function stampCursorGlobalAuthorityMarker(content) {
-  if (CURSOR_GLOBAL_AUTHORITY_MARKER_PATTERN.test(content))
-    return content;
+  const existing = content.match(CURSOR_GLOBAL_AUTHORITY_MARKER_PATTERN);
+  if (existing) {
+    const markerLine2 = existing[0];
+    const index = existing.index ?? content.indexOf(markerLine2);
+    const payload = markerPayload(content, markerLine2, index);
+    if (sha2564(payload) === existing[1].slice("sha256:".length)) {
+      return content;
+    }
+    const digest2 = sha2564(payload);
+    const freshMarkerLine = `<!-- ${CURSOR_GLOBAL_AUTHORITY_MANAGED_MARKER} hash=sha256:${digest2} -->`;
+    return content.slice(0, index) + freshMarkerLine + content.slice(index + markerLine2.length);
+  }
   const digest = sha2564(content);
   const markerLine = `<!-- ${CURSOR_GLOBAL_AUTHORITY_MANAGED_MARKER} hash=sha256:${digest} -->`;
   const frontmatter = content.match(CURSOR_GLOBAL_AUTHORITY_FRONTMATTER_PATTERN)?.[0];
@@ -10871,16 +10984,16 @@ var init_cursor_authority = __esm(() => {
 // src/lib/session-authority.ts
 import { createHash as createHash5 } from "crypto";
 import { lstatSync as lstatSync3, readFileSync as readFileSync3, realpathSync, statSync as statSync2 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join7, resolve as resolve5 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join8, resolve as resolve6 } from "path";
 function sha2565(content) {
   return createHash5("sha256").update(content).digest("hex");
 }
 function configHomeDir() {
-  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir5();
+  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir6();
 }
 function normalizeOwnedTargetPath(p) {
-  const expanded = p.startsWith("~/") ? resolve5(configHomeDir(), p.slice(2)) : resolve5(p);
+  const expanded = p.startsWith("~/") ? resolve6(configHomeDir(), p.slice(2)) : resolve6(p);
   try {
     return realpathSync(expanded);
   } catch {
@@ -10888,7 +11001,7 @@ function normalizeOwnedTargetPath(p) {
   }
 }
 function detectClaudeAuthorityConflicts(targetHome, ownedAuthorities = []) {
-  const authorityPath = resolve5(join7(targetHome, CLAUDE_LEGACY_AUTHORITY_RELATIVE_PATH));
+  const authorityPath = resolve6(join8(targetHome, CLAUDE_LEGACY_AUTHORITY_RELATIVE_PATH));
   let stat;
   try {
     stat = lstatSync3(authorityPath);
@@ -10977,9 +11090,9 @@ var init_session_authority = __esm(() => {
 
 // src/lib/session-render.ts
 import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync4, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
-import { homedir as homedir6 } from "os";
-import { basename as basename4, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute3, join as join8, parse as parse2, posix as posix2, relative as relative2, resolve as resolve6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync4, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
+import { homedir as homedir7 } from "os";
+import { basename as basename4, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute3, join as join9, parse as parse2, posix as posix2, relative as relative2, resolve as resolve7 } from "path";
 function normalizeSessionInstructionLayer(value) {
   if (value === "provider")
     return "tool";
@@ -11065,13 +11178,13 @@ function yamlQuote2(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
 }
 function defaultTargetHome(tool, profile, sessionId) {
-  const home = process.env["HOME"] || homedir6();
-  return join8(home, ".hasna", "accounts", "profiles", tool, slug(profile));
+  const home = process.env["HOME"] || homedir7();
+  return join9(home, ".hasna", "accounts", "profiles", tool, slug(profile));
 }
 function joinTarget(targetHome, relativePath) {
   const safeTargetHome = assertSafeTargetRoot(targetHome);
   const safeRelativePath2 = assertSafeRelativePath(relativePath);
-  return join8(safeTargetHome, ...safeRelativePath2.split("/"));
+  return join9(safeTargetHome, ...safeRelativePath2.split("/"));
 }
 function makeFile(targetHome, relativePath, role, content, sourceIds) {
   const safeTargetHome = assertSafeTargetRoot(targetHome);
@@ -11640,7 +11753,7 @@ function buildOpenCodeFiles(targetHome, adapter, profile, sources, providerConfi
     ...sources.flatMap((source) => source.resolvedRules.map((rule) => rule.id))
   ]);
   const existingConfigPath = joinTarget(targetHome, adapter.configFile);
-  const selectedConfig = existsSync6(existingConfigPath) ? readOpenCodeConfig(readFileSync4(existingConfigPath, "utf8"), existingConfigPath) : providerConfig ? readOpenCodeConfig(providerConfig.content, providerConfig.sourceId) : {};
+  const selectedConfig = existsSync7(existingConfigPath) ? readOpenCodeConfig(readFileSync4(existingConfigPath, "utf8"), existingConfigPath) : providerConfig ? readOpenCodeConfig(providerConfig.content, providerConfig.sourceId) : {};
   const preservedInstructions = normalizeOpenCodeInstructions(selectedConfig["instructions"]).filter((path) => !pathIsManagedOpenCodeInstruction(path, adapter.managedDir));
   const config = {
     ...selectedConfig,
@@ -11829,7 +11942,7 @@ function adapterFor(input) {
   return gatedNativeImports ? CODEWITH_NATIVE_ADAPTER : CODEWITH_FLATTENED_ADAPTER;
 }
 function getHomeDir() {
-  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir6();
+  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir7();
 }
 function cleanSessionPathInput(path) {
   const trimmed = path.trim();
@@ -11844,16 +11957,16 @@ function resolveSessionPath(path) {
     throw new Error("Session render path cannot be empty.");
   const home = getHomeDir();
   if (cleaned === "~")
-    return resolve6(home);
+    return resolve7(home);
   if (cleaned.startsWith("~/"))
-    return resolve6(home, cleaned.slice(2));
+    return resolve7(home, cleaned.slice(2));
   if (cleaned === "{{HOME}}" || cleaned === "${HOME}")
-    return resolve6(home);
+    return resolve7(home);
   if (cleaned.startsWith("{{HOME}}/"))
-    return resolve6(home, cleaned.slice("{{HOME}}/".length));
+    return resolve7(home, cleaned.slice("{{HOME}}/".length));
   if (cleaned.startsWith("${HOME}/"))
-    return resolve6(home, cleaned.slice("${HOME}/".length));
-  return resolve6(cleaned);
+    return resolve7(home, cleaned.slice("${HOME}/".length));
+  return resolve7(cleaned);
 }
 function assertSafeRelativePath(relativePath) {
   if (!relativePath.trim())
@@ -11869,7 +11982,7 @@ function assertSafeRelativePath(relativePath) {
 function assertSafeTargetRoot(targetHome) {
   if (!isAbsolute3(targetHome))
     throw new Error(`Session render target must be an absolute path: ${targetHome}`);
-  const normalized = resolve6(targetHome);
+  const normalized = resolve7(targetHome);
   if (normalized === parse2(normalized).root) {
     throw new Error(`Session render target cannot be the filesystem root: ${targetHome}`);
   }
@@ -12105,7 +12218,7 @@ function planSessionRender(input) {
         sourceId: input.providerConfig.sourceId,
         selectedPayloadSha256: sha2566(input.providerConfig.content),
         renderedPayloadSha256: files.find((file) => file.relativePath === adapter.configFile)?.sha256 ?? sha2566(input.providerConfig.content),
-        selected: !existsSync6(joinTarget(targetHome, adapter.configFile))
+        selected: !existsSync7(joinTarget(targetHome, adapter.configFile))
       }
     } : {},
     ...projectContext ? {
@@ -12366,10 +12479,10 @@ function layerFromIdentityKind(kind, exportShape) {
 function contentFromIdentitySourcePaths(sourcePaths, exportPath, sourceId) {
   if (sourcePaths.length === 0 || !exportPath)
     return;
-  const baseDir = dirname3(resolveSessionPath(exportPath));
+  const baseDir2 = dirname3(resolveSessionPath(exportPath));
   const contents = [];
   for (const sourcePath of sourcePaths) {
-    const content = readIdentitySourcePath(sourcePath, baseDir, sourceId);
+    const content = readIdentitySourcePath(sourcePath, baseDir2, sourceId);
     if (content !== undefined)
       contents.push({ path: sourcePath.path, content });
   }
@@ -12382,9 +12495,9 @@ ${item.content.trimEnd()}`).join(`
 
 `));
 }
-function readIdentitySourcePath(sourcePath, baseDir, sourceId) {
-  const resolvedPath = resolveIdentitySourcePath(sourcePath.path, baseDir, sourceId);
-  if (!existsSync6(resolvedPath)) {
+function readIdentitySourcePath(sourcePath, baseDir2, sourceId) {
+  const resolvedPath = resolveIdentitySourcePath(sourcePath.path, baseDir2, sourceId);
+  if (!existsSync7(resolvedPath)) {
     if (sourcePath.required) {
       throw new Error(`Required identity instruction source path not found for ${sourceId}: ${sourcePath.path}`);
     }
@@ -12394,27 +12507,27 @@ function readIdentitySourcePath(sourcePath, baseDir, sourceId) {
   if (!stat.isFile()) {
     throw new Error(`Identity instruction source path is not a file for ${sourceId}: ${sourcePath.path}`);
   }
-  const realBase = realpathSync2(baseDir);
+  const realBase = realpathSync2(baseDir2);
   const realPath = realpathSync2(resolvedPath);
   if (!pathIsInside(realPath, realBase)) {
     throw new Error(`Identity instruction source path escapes export directory for ${sourceId}: ${sourcePath.path}`);
   }
   return readFileSync4(realPath, "utf-8");
 }
-function resolveIdentitySourcePath(path, baseDir, sourceId) {
+function resolveIdentitySourcePath(path, baseDir2, sourceId) {
   const cleaned = cleanSessionPathInput(path);
   if (!cleaned)
     throw new Error(`Identity instruction source path cannot be empty for ${sourceId}.`);
   if (cleaned.includes("\\"))
     throw new Error(`Identity instruction source path must use POSIX separators for ${sourceId}: ${path}`);
-  const resolvedPath = isAbsolute3(cleaned) ? resolve6(cleaned) : resolve6(baseDir, cleaned);
-  if (!pathIsInside(resolvedPath, resolve6(baseDir))) {
+  const resolvedPath = isAbsolute3(cleaned) ? resolve7(cleaned) : resolve7(baseDir2, cleaned);
+  if (!pathIsInside(resolvedPath, resolve7(baseDir2))) {
     throw new Error(`Identity instruction source path escapes export directory for ${sourceId}: ${path}`);
   }
   return resolvedPath;
 }
-function pathIsInside(path, baseDir) {
-  const rel = relative2(baseDir, path);
+function pathIsInside(path, baseDir2) {
+  const rel = relative2(baseDir2, path);
   return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
 }
 function providerTargetsTool(targets, tool) {
@@ -14074,8 +14187,8 @@ var init_config_store = __esm(() => {
 });
 
 // src/lib/session-render-ownership.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
-import { dirname as dirname4, join as join9, parse as parse3, relative as relative3, sep } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { dirname as dirname4, join as join10, parse as parse3, relative as relative3, sep } from "path";
 function toSegments(absolutePath2) {
   return absolutePath2.replaceAll("\\", "/").split("/").filter(Boolean);
 }
@@ -14094,7 +14207,7 @@ function pathIsSessionRenderManagedDir(absolutePath2) {
 function readManifestRelativePaths(manifestPath) {
   let stats;
   try {
-    if (!existsSync7(manifestPath))
+    if (!existsSync8(manifestPath))
       return null;
     stats = statSync4(manifestPath);
   } catch {
@@ -14123,7 +14236,7 @@ function sessionRenderManifestClaimsPath(absolutePath2) {
   const root = parse3(absolutePath2).root;
   let home = dirname4(absolutePath2);
   for (let depth = 0;depth < MANIFEST_ANCESTOR_LIMIT; depth += 1) {
-    const manifestPath = join9(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
+    const manifestPath = join10(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
     const relativePaths = readManifestRelativePaths(manifestPath);
     if (relativePaths) {
       const claimed = relative3(home, absolutePath2).split(sep).join("/");
@@ -14158,17 +14271,17 @@ __export(exports_apply, {
   applyConfigs: () => applyConfigs,
   applyConfig: () => applyConfig
 });
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync6, realpathSync as realpathSync3, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename5, dirname as dirname5, join as join10, resolve as resolve7 } from "path";
-import { homedir as homedir7 } from "os";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync6, realpathSync as realpathSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename5, dirname as dirname5, join as join11, resolve as resolve8 } from "path";
+import { homedir as homedir8 } from "os";
 function getConfigHome() {
-  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir7();
+  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir8();
 }
 function expandPath(p) {
   if (p.startsWith("~/")) {
-    return resolve7(getConfigHome(), p.slice(2));
+    return resolve8(getConfigHome(), p.slice(2));
   }
-  return resolve7(p);
+  return resolve8(p);
 }
 function normalizeTargetPath(p) {
   const expanded = expandPath(p);
@@ -14178,9 +14291,9 @@ function normalizeTargetPath(p) {
     let current = expanded;
     const missingSegments = [];
     while (true) {
-      if (existsSync8(current)) {
+      if (existsSync9(current)) {
         try {
-          return resolve7(realpathSync3(current), ...missingSegments);
+          return resolve8(realpathSync3(current), ...missingSegments);
         } catch {
           return expanded;
         }
@@ -14209,11 +14322,11 @@ async function writeConfigResult(config, targetPath, content, opts, meta = {}) {
   }
   const path = expandPath(renderedTargetPath);
   const renderedForTarget = isCursorGlobalAuthorityPath(path) ? stampCursorGlobalAuthorityMarker(renderedContent) : renderedContent;
-  const previousContent = existsSync8(path) ? readFileSync6(path, "utf-8") : null;
+  const previousContent = existsSync9(path) ? readFileSync6(path, "utf-8") : null;
   const changed = previousContent !== renderedForTarget;
   if (!opts.dryRun) {
     const dir = dirname5(path);
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     if (previousContent !== null && changed) {
@@ -14247,7 +14360,7 @@ function wouldDestroyACredential(targetPath, renderedContent, format) {
   let current;
   try {
     const path = expandPath(targetPath);
-    if (!existsSync8(path))
+    if (!existsSync9(path))
       return [];
     current = readFileSync6(path, "utf-8");
   } catch {
@@ -14573,7 +14686,7 @@ function sessionRendererOwnsCanonicalTarget(normalized, opts) {
     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(join10(home, ...relativePath.split("/"))))))
+  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join11(home, ...relativePath.split("/"))))))
     return true;
   return sessionRenderOwnsPath(normalized);
 }
@@ -14591,20 +14704,20 @@ var init_apply = __esm(() => {
 });
 
 // src/lib/sync-dir.ts
-import { existsSync as existsSync9, readdirSync, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
-import { join as join11, relative as relative4 } from "path";
-import { homedir as homedir8 } from "os";
+import { existsSync as existsSync10, readdirSync, readFileSync as readFileSync7, statSync as statSync5 } from "fs";
+import { join as join12, relative as relative4 } from "path";
+import { homedir as homedir9 } from "os";
 function shouldSkip(p) {
   return SKIP.some((s) => p.includes(s));
 }
 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) : readdirSync(absDir).map((f) => join11(absDir, f)).filter((f) => statSync5(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync(absDir).map((f) => join12(absDir, f)).filter((f) => statSync5(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
-  const home = homedir8();
+  const home = homedir9();
   const allConfigs = await store.listConfigs();
   for (const file of files) {
     if (shouldSkip(file)) {
@@ -14639,7 +14752,7 @@ async function syncFromDir(dir, opts = {}) {
 }
 async function syncToDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
-  const home = homedir8();
+  const home = homedir9();
   const absDir = expandPath(dir);
   const normalized = dir.startsWith("~/") ? dir : absDir.replace(home, "~");
   const configs = (await store.listConfigs()).filter((c) => c.target_path && (c.target_path.startsWith(normalized) || c.target_path.startsWith(absDir)));
@@ -14663,7 +14776,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join11(dir, entry.name);
+    const full = join12(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -14698,8 +14811,8 @@ __export(exports_sync, {
   KNOWN_CONFIGS: () => KNOWN_CONFIGS,
   CLAUDE_PROMPT_OUTPUTS: () => CLAUDE_PROMPT_OUTPUTS
 });
-import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync8 } from "fs";
-import { basename as basename6, extname as extname3, join as join12 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync8 } from "fs";
+import { basename as basename6, extname as extname3, join as join13 } from "path";
 function claudeRuleOutputs(fileName) {
   const stem = basename6(fileName, extname3(fileName));
   return [
@@ -14738,7 +14851,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);
@@ -14746,7 +14859,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
   const stem = basename6(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);
@@ -14763,8 +14876,8 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join12(absDir, pf.file);
-    if (!existsSync10(abs))
+    const abs = join13(absDir, pf.file);
+    if (!existsSync11(abs))
       continue;
     try {
       const rawContent = readFileSync8(abs, "utf-8");
@@ -14796,19 +14909,19 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join12(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join12(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
-    { dir: join12(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
-    { dir: join12(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
-    { dir: join12(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
-    { dir: join12(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
-    { dir: join12(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
+    { dir: join13(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join13(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
+    { dir: join13(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
+    { dir: join13(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
+    { dir: join13(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
+    { dir: join13(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
+    { dir: join13(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
   ]) {
-    if (!existsSync10(ruleDir.dir))
+    if (!existsSync11(ruleDir.dir))
       continue;
     const mdFiles = readdirSync2(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join12(ruleDir.dir, f);
+      const abs = join13(ruleDir.dir, f);
       const raw = readFileSync8(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
@@ -14848,14 +14961,14 @@ 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 = readdirSync2(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join12(absDir, f);
+        const abs2 = join13(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
@@ -14889,7 +15002,7 @@ async function syncKnown(opts = {}) {
       continue;
     }
     const abs = expandPath(known.path);
-    if (!existsSync10(abs)) {
+    if (!existsSync11(abs)) {
       result.skipped.push(known.path);
       continue;
     }
@@ -14995,7 +15108,7 @@ function storedPlaceholderIsLiteralOnDisk(storedLine, diskLine) {
 }
 function buildDiff(expectedContent, targetPath, storedFormat, showSecrets) {
   const path = expandPath(targetPath);
-  if (!existsSync10(path))
+  if (!existsSync11(path))
     return `(file not found on disk: ${path})`;
   const diskContent = readFileSync8(path, "utf-8");
   if (diskContent === expectedContent)
@@ -15230,16 +15343,16 @@ __export(exports_package_manager_guard, {
   scanPackageManagerSecrets: () => scanPackageManagerSecrets
 });
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync19, lstatSync as lstatSync7, readdirSync as readdirSync5, readFileSync as readFileSync16 } from "fs";
-import { homedir as homedir11 } from "os";
-import { basename as basename7, dirname as dirname10, isAbsolute as isAbsolute5, join as join20, relative as relative7, resolve as resolve13 } from "path";
+import { existsSync as existsSync20, lstatSync as lstatSync7, readdirSync as readdirSync5, readFileSync as readFileSync16 } from "fs";
+import { homedir as homedir12 } from "os";
+import { basename as basename7, dirname as dirname10, isAbsolute as isAbsolute5, join as join21, relative as relative7, resolve as resolve13 } from "path";
 function scanPackageManagerSecrets(options = {}) {
   const cwd = options.cwd ? resolve13(options.cwd) : process.cwd();
   const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve13(cwd, root));
   const findings = [];
   let scannedFiles = 0;
   for (const root of roots) {
-    if (!existsSync19(root))
+    if (!existsSync20(root))
       continue;
     const stat = lstatSync7(root);
     if (stat.isFile()) {
@@ -15266,10 +15379,10 @@ function scanPackageManagerSecrets(options = {}) {
     }
   }
   if (options.includeHome) {
-    const home = homedir11();
+    const home = homedir12();
     for (const name of HOME_FILES) {
-      const file = join20(home, name);
-      if (!existsSync19(file))
+      const file = join21(home, name);
+      if (!existsSync20(file))
         continue;
       const text = readTextFile(file);
       if (text === null)
@@ -15293,12 +15406,12 @@ function collectRepoFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
           continue;
-        visit(join20(dir, entry.name));
+        visit(join21(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const file = join20(dir, entry.name);
+      const file = join21(dir, entry.name);
       if (shouldScanRepoFile(file))
         out.push(file);
     }
@@ -15566,7 +15679,7 @@ function stripInlineComment(value) {
   return value.replace(/\s[#;].*$/, "").trim();
 }
 function displayPath(file, root) {
-  const home = homedir11();
+  const home = homedir12();
   if (root === home && (file === home || file.startsWith(home + "/")))
     return "~/" + toPosix(relative7(home, file));
   if (isAbsolute5(root) && file.startsWith(root + "/"))
@@ -17169,9 +17282,9 @@ var {
 // src/cli/index.tsx
 init_apply();
 import chalk from "chalk";
-import { existsSync as existsSync20, lstatSync as lstatSync8, readFileSync as readFileSync17, readSync, writeSync } from "fs";
-import { homedir as homedir12 } from "os";
-import { basename as basename8, join as join21, resolve as resolve14 } from "path";
+import { existsSync as existsSync21, lstatSync as lstatSync8, readFileSync as readFileSync17, readSync, writeSync } from "fs";
+import { homedir as homedir13 } from "os";
+import { basename as basename8, join as join22, resolve as resolve14 } from "path";
 
 // src/lib/config-target-identity.ts
 init_apply();
@@ -17217,15 +17330,15 @@ init_redact();
 
 // src/lib/export.ts
 init_config_store();
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join13, resolve as resolve8 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join14, resolve as resolve9 } 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 = resolve8(outputPath);
-  const tmpDir = join13(tmpdir(), `configs-export-${Date.now()}`);
-  const contentsDir = join13(tmpDir, "contents");
+  const absOutput = resolve9(outputPath);
+  const tmpDir = join14(tmpdir(), `configs-export-${Date.now()}`);
+  const contentsDir = join14(tmpDir, "contents");
   try {
     mkdirSync4(contentsDir, { recursive: true });
     const manifest = {
@@ -17233,10 +17346,10 @@ async function exportConfigs(outputPath, opts = {}) {
       exported_at: new Date().toISOString(),
       configs: configs.map(({ content: _content, ...meta }) => meta)
     };
-    writeFileSync3(join13(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+    writeFileSync3(join14(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(join13(contentsDir, fileName), config.content, "utf-8");
+      writeFileSync3(join14(contentsDir, fileName), config.content, "utf-8");
     }
     const proc = Bun.spawn(["tar", "czf", absOutput, "-C", tmpDir, "."], {
       stdout: "pipe",
@@ -17249,7 +17362,7 @@ async function exportConfigs(outputPath, opts = {}) {
     }
     return { path: absOutput, count: configs.length };
   } finally {
-    if (existsSync11(tmpDir)) {
+    if (existsSync12(tmpDir)) {
       rmSync3(tmpDir, { recursive: true, force: true });
     }
   }
@@ -17257,14 +17370,14 @@ async function exportConfigs(outputPath, opts = {}) {
 
 // src/lib/import.ts
 init_config_store();
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync9, rmSync as rmSync4 } from "fs";
-import { join as join14, resolve as resolve9 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync9, rmSync as rmSync4 } from "fs";
+import { join as join15, resolve as resolve10 } 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 = resolve9(bundlePath);
-  const tmpDir = join14(tmpdir2(), `configs-import-${Date.now()}`);
+  const absPath = resolve10(bundlePath);
+  const tmpDir = join15(tmpdir2(), `configs-import-${Date.now()}`);
   const result = { created: 0, updated: 0, skipped: 0, errors: [] };
   try {
     mkdirSync5(tmpDir, { recursive: true });
@@ -17277,15 +17390,15 @@ async function importConfigs(bundlePath, opts = {}) {
       const stderr = await new Response(proc.stderr).text();
       throw new Error(`tar extraction failed: ${stderr}`);
     }
-    const manifestPath = join14(tmpDir, "manifest.json");
-    if (!existsSync12(manifestPath))
+    const manifestPath = join15(tmpDir, "manifest.json");
+    if (!existsSync13(manifestPath))
       throw new Error("Invalid bundle: missing manifest.json");
     const manifest = JSON.parse(readFileSync9(manifestPath, "utf-8"));
     for (const meta of manifest.configs) {
       try {
         const ext = meta.format === "text" ? "txt" : meta.format;
-        const contentFile = join14(tmpDir, "contents", `${meta.slug}.${ext}`);
-        const content = existsSync12(contentFile) ? readFileSync9(contentFile, "utf-8") : "";
+        const contentFile = join15(tmpDir, "contents", `${meta.slug}.${ext}`);
+        const content = existsSync13(contentFile) ? readFileSync9(contentFile, "utf-8") : "";
         let existing = null;
         try {
           existing = await store.getConfig(meta.slug);
@@ -17319,7 +17432,7 @@ async function importConfigs(bundlePath, opts = {}) {
     }
     return result;
   } finally {
-    if (existsSync12(tmpDir)) {
+    if (existsSync13(tmpDir)) {
       rmSync4(tmpDir, { recursive: true, force: true });
     }
   }
@@ -17336,14 +17449,14 @@ init_cursor_authority();
 init_session_authority();
 import { createHash as createHash8, randomUUID as randomUUID7 } from "crypto";
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   lstatSync as lstatSync4,
   mkdirSync as mkdirSync6,
   readFileSync as readFileSync10,
   readdirSync as readdirSync3,
   statSync as statSync6
 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join15, parse as parse4, relative as relative5, resolve as resolve10 } from "path";
+import { dirname as dirname6, isAbsolute as isAbsolute4, join as join16, parse as parse4, relative as relative5, resolve as resolve11 } from "path";
 
 class SessionApplyError extends Error {
   constructor(message) {
@@ -17475,13 +17588,13 @@ function assertClaudeAuthorityStillClear(plan, targetHome, ownedClaudeAuthoritie
   throw new SessionApplyError(`Claude authority changed after planning; refusing to apply: ${summary}`);
 }
 function ensureSessionTargetHome(targetHome) {
-  if (!existsSync13(targetHome))
+  if (!existsSync14(targetHome))
     mkdirSync6(targetHome, { recursive: true, mode: 448 });
   assertSafeTargetHome(targetHome);
 }
 function checkSessionRenderDrift(targetHome, manifestPath) {
   const safeTargetHome = assertSafeTargetHome(targetHome);
-  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative5(safeTargetHome, resolve10(manifestPath)), safeTargetHome) : resolve10(safeTargetHome, ".hasna", "session-render-manifest.json");
+  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative5(safeTargetHome, resolve11(manifestPath)), safeTargetHome) : resolve11(safeTargetHome, ".hasna", "session-render-manifest.json");
   const checkedAt = new Date().toISOString();
   const previousManifest = readPreviousManifest(resolvedManifestPath);
   if (!previousManifest) {
@@ -17498,7 +17611,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
   const drifted = [];
   for (const file of previousManifest.files) {
     const target = resolveManifestRelativePath(file.relativePath, safeTargetHome);
-    if (!existsSync13(target)) {
+    if (!existsSync14(target)) {
       missing.push({
         path: target,
         relativePath: file.relativePath,
@@ -17531,7 +17644,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
 function restoreSessionRenderSnapshot(snapshotPath, options = {}) {
   const snapshot = readSessionRenderSnapshot(snapshotPath);
   const targetHome = assertSafeTargetHome(snapshot.targetHome);
-  const resolvedSnapshotPath = resolve10(snapshotPath);
+  const resolvedSnapshotPath = resolve11(snapshotPath);
   const snapshotRelativePath = relative5(targetHome, resolvedSnapshotPath);
   if (snapshotRelativePath === "" || snapshotRelativePath === ".." || snapshotRelativePath.startsWith("../") || isAbsolute4(snapshotRelativePath)) {
     throw new SessionApplyError("Session snapshot must be stored inside its target home.");
@@ -17649,8 +17762,8 @@ function requiredRestoreHash(file) {
   return file.previousSha256;
 }
 function readSessionRenderSnapshot(snapshotPath) {
-  const resolved = resolve10(snapshotPath);
-  if (!existsSync13(resolved))
+  const resolved = resolve11(snapshotPath);
+  if (!existsSync14(resolved))
     throw new SessionApplyError(`Session snapshot not found: ${snapshotPath}`);
   const stat = lstatSync4(resolved);
   if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -17730,7 +17843,7 @@ function readSessionRenderSnapshot(snapshotPath) {
 }
 function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previousManifestFiles, targetHome, snapshotPath) {
   assertNoNewerSessionSnapshot(snapshotPath, snapshot.createdAt, targetHome);
-  const manifestPath = resolve10(snapshot.manifestPath);
+  const manifestPath = resolve11(snapshot.manifestPath);
   const manifestRelativePath = relative5(targetHome, manifestPath).replaceAll("\\", "/");
   resolveSnapshotFilePath(manifestRelativePath, snapshot.manifestPath, targetHome);
   const manifestSha256 = currentSessionFileHash(manifestPath, targetHome);
@@ -17747,7 +17860,7 @@ function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previou
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest is invalid: ${snapshotPath}`);
   }
   const appliedManifest = parsedManifest;
-  if (appliedManifest.schema !== SESSION_RENDER_SCHEMA || appliedManifest.tool !== snapshot.tool || appliedManifest.profile !== snapshot.profile || typeof appliedManifest.targetHome !== "string" || resolve10(appliedManifest.targetHome) !== targetHome || appliedManifest.targetKind !== "session-home" && appliedManifest.targetKind !== "project-root" || !Array.isArray(appliedManifest.files)) {
+  if (appliedManifest.schema !== SESSION_RENDER_SCHEMA || appliedManifest.tool !== snapshot.tool || appliedManifest.profile !== snapshot.profile || typeof appliedManifest.targetHome !== "string" || resolve11(appliedManifest.targetHome) !== targetHome || appliedManifest.targetKind !== "session-home" && appliedManifest.targetKind !== "project-root" || !Array.isArray(appliedManifest.files)) {
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest does not match its snapshot: ${snapshotPath}`);
   }
   const afterFiles = [];
@@ -17832,8 +17945,8 @@ function assertNoNewerSessionSnapshot(snapshotPath, createdAt, targetHome) {
     throw new SessionApplyError(`Pre-rollback legacy v1 snapshot has an invalid creation time: ${snapshotPath}`);
   }
   for (const entry of readdirSync3(dirname6(snapshotPath))) {
-    const candidatePath = resolve10(dirname6(snapshotPath), entry);
-    if (candidatePath === resolve10(snapshotPath) || !entry.endsWith(".json"))
+    const candidatePath = resolve11(dirname6(snapshotPath), entry);
+    if (candidatePath === resolve11(snapshotPath) || !entry.endsWith(".json"))
       continue;
     const candidateStat = lstatSync4(candidatePath);
     if (candidateStat.isSymbolicLink() || !candidateStat.isFile() || candidateStat.size > 32 * 1024 * 1024)
@@ -17841,7 +17954,7 @@ function assertNoNewerSessionSnapshot(snapshotPath, createdAt, targetHome) {
     try {
       const candidate = JSON.parse(readFileSync10(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" && resolve10(candidate.targetHome) === targetHome && Number.isFinite(candidateCreatedAtMs) && candidateCreatedAtMs >= createdAtMs) {
+      if ((candidate.schema === "hasna.configs.session-render-snapshot/v1" || candidate.schema === "hasna.configs.session-render-snapshot/v2") && typeof candidate.targetHome === "string" && resolve11(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}`);
       }
     } catch (error) {
@@ -17910,14 +18023,14 @@ function inferLegacySnapshotAction(file, previousFiles, previousManifestFiles, p
 }
 function resolveSnapshotFilePath(relativePath, recordedPath, targetHome) {
   const path = resolveManifestRelativePath(relativePath, targetHome);
-  if (resolve10(recordedPath) !== path) {
+  if (resolve11(recordedPath) !== path) {
     throw new SessionApplyError(`Session snapshot file path mismatch for ${relativePath}`);
   }
   return path;
 }
 function planFileResult(plan, file, targetHome, previousHashes, previousManifest, options) {
   const target = resolvePlannedFilePath(plan, file, targetHome);
-  const previousContent = existsSync13(target) ? readFileSync10(target, "utf-8") : null;
+  const previousContent = existsSync14(target) ? readFileSync10(target, "utf-8") : null;
   const previousSha256 = previousContent === null ? null : sha2568(previousContent);
   const previouslyManaged = isPreviouslyManaged(file, previousSha256, previousHashes, previousManifest);
   const changed = previousContent !== file.content;
@@ -18016,7 +18129,7 @@ function planStaleFileResults(plan, targetHome, previousManifest, currentRelativ
 }
 function planStaleFileResult(file, targetHome, options) {
   const target = resolveManifestRelativePath(file.relativePath, targetHome);
-  if (!existsSync13(target))
+  if (!existsSync14(target))
     return null;
   const previousContent = readFileSync10(target, "utf-8");
   const previousSha256 = sha2568(previousContent);
@@ -18063,19 +18176,19 @@ function isPreviouslyManaged(file, previousSha256, previousHashes, previousManif
   return previousHashes.get(file.relativePath) === previousSha256;
 }
 function resolvePlannedFilePath(plan, file, targetHome) {
-  const target = resolve10(targetHome, ...file.relativePath.split("/"));
+  const target = resolve11(targetHome, ...file.relativePath.split("/"));
   const rel = relative5(targetHome, target);
   if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute4(rel)) {
     throw new SessionApplyError(`Session file escapes target home: ${file.relativePath}`);
   }
-  if (resolve10(file.path) !== target) {
+  if (resolve11(file.path) !== target) {
     throw new SessionApplyError(`Session file path mismatch for ${file.relativePath}: ${file.path}`);
   }
   assertNoSymlinkSegments2(targetHome, target);
   return target;
 }
 function resolveManifestRelativePath(relativePath, targetHome) {
-  const target = resolve10(targetHome, ...relativePath.split(/[\\/]+/));
+  const target = resolve11(targetHome, ...relativePath.split(/[\\/]+/));
   const rel = relative5(targetHome, target);
   if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute4(rel)) {
     throw new SessionApplyError(`Session manifest file escapes target home: ${relativePath}`);
@@ -18084,7 +18197,7 @@ function resolveManifestRelativePath(relativePath, targetHome) {
   return target;
 }
 function readPreviousManifest(path) {
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync10(path, "utf-8"));
@@ -18126,7 +18239,7 @@ function assertExpectedSessionFileHash(path, targetHome, expectedHash) {
 }
 function currentSessionFileHash(path, targetHome) {
   assertNoSymlinkSegments2(targetHome, path);
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return null;
   const stat = lstatSync4(path);
   if (stat.isSymbolicLink() || !stat.isFile()) {
@@ -18141,7 +18254,7 @@ 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) => existsSync13(result.path)).map((result) => {
+  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").filter((result) => existsSync14(result.path)).map((result) => {
     const content = readFileSync10(result.path, "utf-8");
     return {
       path: result.path,
@@ -18160,7 +18273,7 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
     };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const snapshotPath = resolve10(targetHome, ".hasna", "session-render-snapshots", `${timestamp}-${randomUUID7()}.json`);
+  const snapshotPath = resolve11(targetHome, ".hasna", "session-render-snapshots", `${timestamp}-${randomUUID7()}.json`);
   const afterFiles = results.map((result) => {
     if (result.action === "conflict") {
       throw new SessionApplyError(`Cannot snapshot unresolved conflict: ${result.relativePath}`);
@@ -18208,12 +18321,12 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
 function assertSafeTargetHome(targetHome) {
   if (!isAbsolute4(targetHome))
     throw new SessionApplyError(`Session target home must be absolute: ${targetHome}`);
-  const normalized = resolve10(targetHome);
+  const normalized = resolve11(targetHome);
   if (normalized === parse4(normalized).root) {
     throw new SessionApplyError(`Session target home cannot be the filesystem root: ${targetHome}`);
   }
   assertNoSymlinkAncestors2(normalized);
-  if (existsSync13(normalized) && lstatSync4(normalized).isSymbolicLink()) {
+  if (existsSync14(normalized) && lstatSync4(normalized).isSymbolicLink()) {
     throw new SessionApplyError(`Session target home cannot be a symlink: ${normalized}`);
   }
   return normalized;
@@ -18223,20 +18336,20 @@ function assertNoSymlinkSegments2(root, target) {
   const rel = relative5(root, target);
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join15(current, segment);
-    if (existsSync13(current) && lstatSync4(current).isSymbolicLink()) {
+    current = join16(current, segment);
+    if (existsSync14(current) && lstatSync4(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink: ${current}`);
     }
   }
 }
 function assertNoSymlinkAncestors2(path) {
-  const normalized = resolve10(path);
+  const normalized = resolve11(path);
   const parsed = parse4(normalized);
   let current = parsed.root;
   const rel = relative5(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join15(current, segment);
-    if (!existsSync13(current))
+    current = join16(current, segment);
+    if (!existsSync14(current))
       return;
     if (lstatSync4(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink ancestor: ${current}`);
@@ -18285,10 +18398,11 @@ function formatGlobalSourceCoverageWarnings(result) {
 }
 
 // src/lib/station-profile.ts
+init_raw_store_root();
 import { spawnSync } from "child_process";
-import { existsSync as existsSync14, lstatSync as lstatSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync11, readdirSync as readdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { arch as osArch, homedir as homedir9, hostname as osHostname, platform as osPlatform, userInfo as osUserInfo } from "os";
-import { dirname as dirname7, join as join16, resolve as resolve11 } from "path";
+import { existsSync as existsSync15, lstatSync as lstatSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync11, readdirSync as readdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { arch as osArch, homedir as homedir10, hostname as osHostname, platform as osPlatform, userInfo as osUserInfo } from "os";
+import { dirname as dirname7, join as join17 } from "path";
 var STATION_PROFILE_CACHE_FILENAME = "station-profile.md";
 var STATION_PROFILE_SOURCE_ID = "station-profile";
 var STATION_PROFILE_LAYER = "machine";
@@ -18298,22 +18412,21 @@ var STATION_PROFILE_FULL_NAMES_MAX = 6;
 var STATION_PROFILE_PRIMARY_SCOPE = "@hasna";
 var MACHINES_MANIFEST_PATH_ENV = "HASNA_MACHINES_MANIFEST_PATH";
 var BUN_INSTALL_ENV = "BUN_INSTALL";
-function homeDir2(env = process.env) {
-  return env["HOME"] || env["USERPROFILE"] || homedir9();
+function homeDir3(env = process.env) {
+  return env["HOME"] || env["USERPROFILE"] || homedir10();
 }
 function getStationProfileCachePath(env = process.env) {
-  const root = env["HASNA_CONFIGS_HOME"] || join16(homeDir2(env), ".hasna", "instructions");
-  return join16(resolve11(root), STATION_PROFILE_CACHE_FILENAME);
+  return join17(getRawStoreRoot(env), STATION_PROFILE_CACHE_FILENAME);
 }
 function getMachinesManifestPath(env = process.env) {
-  return env[MACHINES_MANIFEST_PATH_ENV] || join16(homeDir2(env), ".hasna", "machines", "machines.json");
+  return env[MACHINES_MANIFEST_PATH_ENV] || join17(homeDir3(env), ".hasna", "machines", "machines.json");
 }
 function getBunGlobalModulesDir(env = process.env) {
-  return join16(env[BUN_INSTALL_ENV] || join16(homeDir2(env), ".bun"), "install", "global", "node_modules");
+  return join17(env[BUN_INSTALL_ENV] || join17(homeDir3(env), ".bun"), "install", "global", "node_modules");
 }
 function readMachinesManifest(path) {
   try {
-    if (!existsSync14(path))
+    if (!existsSync15(path))
       return null;
     const parsed = JSON.parse(readFileSync11(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
@@ -18369,9 +18482,9 @@ function probeMachineStatus(machineId) {
 function resolveStationProfileMachine(env = process.env, options = {}) {
   const hostname2 = osHostname();
   const record = findLocalManifestMachine(readMachinesManifest(getMachinesManifestPath(env)), hostname2);
-  const home = homeDir2(env);
+  const home = homeDir3(env);
   const platform = stringField(record, "platform") ?? osPlatform();
-  const workspacePath = stringField(record, "workspacePath") ?? join16(home, platform === "darwin" ? "Workspace" : "workspace");
+  const workspacePath = stringField(record, "workspacePath") ?? join17(home, platform === "darwin" ? "Workspace" : "workspace");
   const machine = {
     id: stringField(record, "id") ?? hostname2,
     hostname: stringField(record, "hostname") ?? hostname2,
@@ -18388,9 +18501,9 @@ function resolveStationProfileMachine(env = process.env, options = {}) {
   return machine;
 }
 function scopedPackageNames(modulesDir, scope) {
-  const scopeDir = join16(modulesDir, scope);
+  const scopeDir = join17(modulesDir, scope);
   try {
-    if (!existsSync14(scopeDir))
+    if (!existsSync15(scopeDir))
       return null;
     return readdirNames(scopeDir).sort();
   } catch {
@@ -18400,7 +18513,7 @@ function scopedPackageNames(modulesDir, scope) {
 function readdirNames(dir) {
   return readdirSync4(dir).filter((name) => {
     try {
-      return lstatSync5(join16(dir, name)).isDirectory();
+      return lstatSync5(join17(dir, name)).isDirectory();
     } catch {
       return false;
     }
@@ -18410,7 +18523,7 @@ function resolveStationProfilePackages(env = process.env) {
   const modulesDir = getBunGlobalModulesDir(env);
   let scopeDirs;
   try {
-    if (!existsSync14(modulesDir))
+    if (!existsSync15(modulesDir))
       return null;
     scopeDirs = readdirNames(modulesDir).filter((name) => name.startsWith("@") && name.toLowerCase().includes("hasna"));
   } catch {
@@ -18485,7 +18598,7 @@ function refreshStationProfile(options = {}) {
   const path = getStationProfileCachePath(env);
   const generatedAt = new Date().toISOString();
   if (!options.dryRun) {
-    const existing = existsSync14(path) ? readFileSync11(path, "utf8") : null;
+    const existing = existsSync15(path) ? readFileSync11(path, "utf8") : null;
     if (existing !== content) {
       mkdirSync7(dirname7(path), { recursive: true });
       writeFileSync4(path, content, "utf8");
@@ -18504,7 +18617,7 @@ function refreshStationProfile(options = {}) {
 function readStationProfile(env = process.env) {
   const path = getStationProfileCachePath(env);
   try {
-    if (!existsSync14(path))
+    if (!existsSync15(path))
       return null;
     return readFileSync11(path, "utf8");
   } catch {
@@ -18843,7 +18956,7 @@ init_codewith_shared_todos_storage_standard();
 import { createHash as createHash9 } from "crypto";
 import { spawnSync as spawnSync2 } from "child_process";
 import {
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   lstatSync as lstatSync6,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync12,
@@ -18851,8 +18964,8 @@ import {
   rmSync as rmSync5,
   writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir10 } from "os";
-import { dirname as dirname8, join as join17, parse as parse5, relative as relative6, resolve as resolve12 } from "path";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname8, join as join18, parse as parse5, relative as relative6, resolve as resolve12 } from "path";
 var INBOX_CONVERSATIONS_MINIMUM_VERSION = "0.5.28";
 var INBOX_SKILL_MARKERS = [
   [".claude", "skills", "inbox", "SKILL.md"],
@@ -18878,8 +18991,8 @@ function findSymlinkedAncestor(path) {
   let current = parsed.root;
   const rel = relative6(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join17(current, segment);
-    if (!existsSync15(current))
+    current = join18(current, segment);
+    if (!existsSync16(current))
       return null;
     if (lstatSync6(current).isSymbolicLink())
       return current;
@@ -18896,11 +19009,11 @@ function packagedInboxSkillPath(explicitPath) {
   if (explicitPath)
     return explicitPath;
   const candidates = [
-    join17(import.meta.dir, "..", "..", "assets", "skills", "inbox", "SKILL.md"),
-    join17(import.meta.dir, "..", "assets", "skills", "inbox", "SKILL.md"),
-    join17(process.cwd(), "assets", "skills", "inbox", "SKILL.md")
+    join18(import.meta.dir, "..", "..", "assets", "skills", "inbox", "SKILL.md"),
+    join18(import.meta.dir, "..", "assets", "skills", "inbox", "SKILL.md"),
+    join18(process.cwd(), "assets", "skills", "inbox", "SKILL.md")
   ];
-  const found = candidates.find((candidate) => existsSync15(candidate));
+  const found = candidates.find((candidate) => existsSync16(candidate));
   if (!found) {
     throw new Error(`packaged inbox skill contract is missing (checked ${candidates.length} package-relative locations)`);
   }
@@ -18949,8 +19062,8 @@ function compareVersions(left, right) {
   }
   return 0;
 }
-function inspectSkillMarkers(homeDir3) {
-  return INBOX_SKILL_MARKERS.map((parts) => join17(homeDir3, ...parts)).map((path) => {
+function inspectSkillMarkers(homeDir4) {
+  return INBOX_SKILL_MARKERS.map((parts) => join18(homeDir4, ...parts)).map((path) => {
     const stat = lstatOrNull(path);
     if (!stat)
       return null;
@@ -18966,9 +19079,9 @@ function inspectSkillMarkers(homeDir3) {
   }).filter((snapshot) => snapshot !== null);
 }
 function inspectInbox(options) {
-  const homeDir3 = options.homeDir ?? homedir10();
+  const homeDir4 = options.homeDir ?? homedir11();
   const runtimeCommand = options.conversationsCommand ?? "conversations";
-  const snapshots = inspectSkillMarkers(homeDir3);
+  const snapshots = inspectSkillMarkers(homeDir4);
   const skillPresent = snapshots.length > 0;
   let canonicalContent = null;
   let canonicalSha256 = null;
@@ -19243,11 +19356,11 @@ init_project_context();
 init_config_store();
 init_apply();
 init_config_agents();
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
 
 // src/lib/package-version.ts
-import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
-import { dirname as dirname9, join as join18 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname9, join as join19 } from "path";
 import { fileURLToPath } from "url";
 var cached = null;
 function getPackageVersion() {
@@ -19256,8 +19369,8 @@ function getPackageVersion() {
   try {
     let dir = dirname9(fileURLToPath(import.meta.url));
     for (let i = 0;i < 8; i++) {
-      const pkgPath = join18(dir, "package.json");
-      if (existsSync16(pkgPath)) {
+      const pkgPath = join19(dir, "package.json");
+      if (existsSync17(pkgPath)) {
         const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
         if (pkg.name === "@hasna/instructions" && pkg.version) {
           cached = pkg.version;
@@ -19321,7 +19434,7 @@ async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
       continue;
     knownTargets += 1;
     const targetPath = expandPath(config.target_path);
-    if (!existsSync17(targetPath)) {
+    if (!existsSync18(targetPath)) {
       missingTargets += 1;
       continue;
     }
@@ -19421,8 +19534,8 @@ init_config_store();
 
 // src/lib/provider-context.ts
 import { createHash as createHash10 } from "crypto";
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
+import { join as join20 } from "path";
 var PROVIDER_CONTEXT_DIR = ".hasna/provider-context";
 var PROVIDER_CONTEXT_MANIFEST = "manifest.json";
 var PROVIDER_CONTEXT_SCHEMA = "hasna.instructions.provider-context/v1";
@@ -19567,17 +19680,17 @@ function resolveAndRenderProviderContext(opts) {
   const recordedEndpoint = originAccepted ? `${opts.origin.host}${opts.origin.pathPrefix || ""}` : null;
   const reason = entry === null && opts.rawEndpoint ? originAccepted ? `endpoint "${recordedEndpoint}" is not in the provider-context registry; using the invariant fragment` : "endpoint rejected (embedded credentials or unparseable); using the invariant fragment" : null;
   const content = renderProviderFragment(entry);
-  const dir = join19(opts.homeDir, PROVIDER_CONTEXT_DIR);
-  if (!existsSync18(dir))
+  const dir = join20(opts.homeDir, PROVIDER_CONTEXT_DIR);
+  if (!existsSync19(dir))
     mkdirSync9(dir, { recursive: true });
   const filename = `${entry ? entry.key : "invariant"}.md`;
-  const fragmentPath2 = join19(dir, filename);
+  const fragmentPath2 = join20(dir, filename);
   const fragmentSha256 = sha25610(content);
   writeFileSync6(fragmentPath2, content, "utf8");
-  const manifestPath = join19(dir, PROVIDER_CONTEXT_MANIFEST);
+  const manifestPath = join20(dir, PROVIDER_CONTEXT_MANIFEST);
   let manifest = { schema: PROVIDER_CONTEXT_SCHEMA, fragments: {} };
   try {
-    if (existsSync18(manifestPath)) {
+    if (existsSync19(manifestPath)) {
       const parsed = JSON.parse(readFileSync15(manifestPath, "utf8"));
       if (parsed && typeof parsed === "object")
         manifest = parsed;
@@ -19721,7 +19834,7 @@ function parseSessionSource(value, order) {
   if (!path)
     throw new Error(`Invalid --source "${value}" (expected path or id=path)`);
   const absPath = resolveSessionPath(path);
-  if (!existsSync20(absPath))
+  if (!existsSync21(absPath))
     throw new Error(`Instruction source file not found: ${absPath}`);
   const content = readSessionInstructionSourceFile(absPath);
   const source = sourceFromFilePath(absPath, content, order);
@@ -19802,7 +19915,7 @@ async function collectSessionSources(opts, tool, store) {
   }
   for (const value of opts.identityExport ?? []) {
     const path = resolveSessionPath(value);
-    if (!existsSync20(path))
+    if (!existsSync21(path))
       throw new Error(`Identity instruction export not found: ${path}`);
     const parsed = JSON.parse(readFileSync17(path, "utf-8"));
     sources.push(...sourcesFromIdentityExport(parsed, { path, tool, orderOffset: sources.length }));
@@ -19936,7 +20049,7 @@ function readProjectContextBundleOption(value, allowMissing = false) {
   if (value === "-")
     return { json: readBoundedProjectContextStdin() };
   const path = resolveSessionPath(value);
-  if (!existsSync20(path)) {
+  if (!existsSync21(path)) {
     if (allowMissing)
       return {};
     throw new ProjectContextError("PROJECT_CONTEXT_INPUT_MISSING", `bundle file not found: ${path}`);
@@ -20108,7 +20221,7 @@ program.command("tag <id>").description("Add or remove tags on a stored config (
 });
 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)").option("--update", "if a config already owns this path, update that row in place instead of refusing").action(async (filePath, opts) => {
   const abs = resolve14(filePath);
-  if (!existsSync20(abs)) {
+  if (!existsSync21(abs)) {
     console.error(chalk.red(`File not found: ${abs}`));
     process.exit(1);
   }
@@ -20116,7 +20229,7 @@ program.command("add <path>").description("Ingest a file into the config DB").op
   const storedFmt = detectFormat(abs);
   const fmt = redactFormatForTarget(abs, storedFmt);
   const { content, redacted, isTemplate: isTemplate2 } = redactContent(rawContent, fmt);
-  const targetPath = abs.startsWith(homedir12()) ? abs.replace(homedir12(), "~") : abs;
+  const targetPath = abs.startsWith(homedir13()) ? abs.replace(homedir13(), "~") : abs;
   const name = opts.name || filePath.split("/").pop();
   const store = resolveConfigStore();
   const allConfigs = await store.listConfigs();
@@ -20291,7 +20404,7 @@ program.command("sync").description("Sync known AI coding configs from disk into
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const projDir = join21(absDir, entry.name);
+        const projDir = join22(absDir, entry.name);
         const hasAgentConfig = [
           "CLAUDE.md",
           ".mcp.json",
@@ -20304,7 +20417,7 @@ program.command("sync").description("Sync known AI coding configs from disk into
           ".aicopilot",
           ".cursor",
           ".agents"
-        ].some((marker) => existsSync20(join21(projDir, marker)));
+        ].some((marker) => existsSync21(join22(projDir, marker)));
         if (!hasAgentConfig)
           continue;
         const result2 = await syncProject({ projectDir: projDir, dryRun: opts.dryRun, store });
@@ -20355,7 +20468,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 = isApiTransport() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join21(getRawStoreRoot(), "instructions.db");
+  const dbPath = isApiTransport() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join22(getRawStoreRoot(), "instructions.db");
   const stats = await store.getConfigStats();
   console.log(chalk.bold("@hasna/instructions") + chalk.dim(" v" + pkg.version));
   console.log(chalk.cyan(isApiTransport() ? "API:" : "DB:") + " " + dbPath);
@@ -21234,7 +21347,7 @@ mcpCmd.command("install").alias("add").description("Install configs MCP server i
       } else if (target === "codex") {
         const { appendFileSync, existsSync: ex } = await import("fs");
         const { join: j } = await import("path");
-        const configPath = j(homedir12(), ".codex", "config.toml");
+        const configPath = j(homedir13(), ".codex", "config.toml");
         const block = `
 [mcp_servers.configs]
 command = "${mcpBinary}"
@@ -21252,7 +21365,7 @@ args = []
       } else if (target === "antigravity") {
         const { mkdirSync: md, readFileSync: rf, writeFileSync: wf, existsSync: ex } = await import("fs");
         const { dirname: dn, join: j } = await import("path");
-        const configPath = j(homedir12(), ".gemini", "config", "mcp_config.json");
+        const configPath = j(homedir13(), ".gemini", "config", "mcp_config.json");
         let settings = {};
         if (ex(configPath)) {
           try {
@@ -21336,7 +21449,7 @@ DB stats:`));
     if (count > 0)
       console.log(`  ${key.padEnd(18)} ${count}`);
   }
-  const location = isApiTransport() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join21(getRawStoreRoot(), "instructions.db");
+  const location = isApiTransport() ? `${process.env["HASNA_INSTRUCTIONS_API_URL"]}/v1` : process.env["HASNA_INSTRUCTIONS_DB_PATH"] || join22(getRawStoreRoot(), "instructions.db");
   console.log(chalk.dim(`
 ${isApiTransport() ? "API" : "DB"}: ${location}`));
 });
@@ -21397,10 +21510,10 @@ managedSkillsCmd.command("apply").option("--dry-run", "preview without writing")
 });
 program.command("backup").description("Export configs to a timestamped backup file").action(async () => {
   const { mkdirSync: mk } = await import("fs");
-  const backupDir = join21(getRawStoreRoot(), "backups");
+  const backupDir = join22(getRawStoreRoot(), "backups");
   mk(backupDir, { recursive: true });
   const ts = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "-").slice(0, 19);
-  const outPath = join21(backupDir, `configs-${ts}.tar.gz`);
+  const outPath = join22(backupDir, `configs-${ts}.tar.gz`);
   const result = await exportConfigs(outPath, { store: resolveConfigStore() });
   const { statSync: st } = await import("fs");
   const size = st(outPath).size;
@@ -21428,9 +21541,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) {
-      existsSync20(expandPath(k.rulesDir)) ? pass(`${k.rulesDir}/ exists`) : k.optional ? skip(`${k.rulesDir}/ (optional)`) : fail2(`${k.rulesDir}/ not found`);
+      existsSync21(expandPath(k.rulesDir)) ? pass(`${k.rulesDir}/ exists`) : k.optional ? skip(`${k.rulesDir}/ (optional)`) : fail2(`${k.rulesDir}/ not found`);
     } else {
-      existsSync20(expandPath(k.path)) ? pass(k.path) : k.optional ? skip(`${k.path} (optional)`) : fail2(`${k.path} not found`);
+      existsSync21(expandPath(k.path)) ? pass(k.path) : k.optional ? skip(`${k.path} (optional)`) : fail2(`${k.path} not found`);
     }
   }
   const allConfigs = await store.listConfigs();
@@ -21584,16 +21697,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 (!existsSync20(absDir))
+      if (!existsSync21(absDir))
         continue;
       const { readdirSync: readdirSync6 } = await import("fs");
       for (const f of readdirSync6(absDir).filter((f2) => f2.endsWith(".md"))) {
-        const abs = join21(absDir, f);
+        const abs = join22(absDir, f);
         mtimes.set(abs, st(abs).mtimeMs);
       }
     } else {
       const abs = expandPath2(k.path);
-      if (existsSync20(abs))
+      if (existsSync21(abs))
         mtimes.set(abs, st(abs).mtimeMs);
     }
   }
@@ -21601,7 +21714,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 (!existsSync20(abs))
+      if (!existsSync21(abs))
         continue;
       const newMtime = st(abs).mtimeMs;
       if (newMtime !== oldMtime) {
@@ -21613,10 +21726,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 (!existsSync20(absDir))
+        if (!existsSync21(absDir))
           continue;
         for (const f of rd(absDir).filter((f2) => f2.endsWith(".md"))) {
-          const abs = join21(absDir, f);
+          const abs = join22(absDir, f);
           if (!mtimes.has(abs)) {
             mtimes.set(abs, st(abs).mtimeMs);
             changed++;
@@ -21624,7 +21737,7 @@ program.command("watch").description("Watch known config files for changes and a
         }
       } else {
         const abs = expandPath2(k.path);
-        if (existsSync20(abs) && !mtimes.has(abs)) {
+        if (existsSync21(abs) && !mtimes.has(abs)) {
           mtimes.set(abs, st(abs).mtimeMs);
           changed++;
         }
@@ -21652,7 +21765,7 @@ program.command("report").description("Summary of stored configs, drift, and eco
     if (!c.target_path)
       continue;
     const abs = expandPath(c.target_path);
-    if (!existsSync20(abs)) {
+    if (!existsSync21(abs)) {
       missing++;
       continue;
     }
@@ -21723,7 +21836,7 @@ program.command("clean").description("Remove configs from DB whose target files
     if (!c.target_path)
       continue;
     const abs = expandPath(c.target_path);
-    if (!existsSync20(abs)) {
+    if (!existsSync21(abs)) {
       if (printed < maxPrinted) {
         if (opts.dryRun) {
           console.log(chalk.yellow("  would remove:") + ` ${c.slug} ${chalk.dim(`(${truncateMiddle(c.target_path, 88)})`)}`);
@@ -21869,13 +21982,13 @@ providerContextCmd.command("resolve").description("Resolve the endpoint to a pro
   try {
     const rawEndpoint = opts.endpoint ?? process.env["ANTHROPIC_BASE_URL"] ?? "";
     const rawModel = opts.model ?? process.env["ANTHROPIC_MODEL"] ?? "";
-    const homeDir3 = opts.home ?? homedir12();
+    const homeDir4 = opts.home ?? homedir13();
     const origin = normalizeEndpointOrigin(rawEndpoint);
     const resolution = resolveAndRenderProviderContext({
       origin,
       rawEndpoint,
       rawModel,
-      homeDir: homeDir3
+      homeDir: homeDir4
     });
     if (opts.json) {
       printJson({