@hasna/instructions 0.4.36 → 0.4.39

package/dist/index.js

@@ -104,16 +104,46 @@ import { randomUUID as randomUUID3 } from "crypto";
 // src/db/database.ts
 import { Database } from "bun:sqlite";
 import { existsSync, mkdirSync, rmSync } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 import { randomUUID } from "crypto";
+
+// src/lib/retired-storage-mode.ts
+var LEGACY_STORAGE_MODE_KEYS = [
+  "HASNA_INSTRUCTIONS_STORAGE_MODE",
+  "HASNA_INSTRUCTIONS_MODE",
+  "INSTRUCTIONS_STORAGE_MODE",
+  "INSTRUCTIONS_MODE"
+];
+function firstDefinedEnvKey(env, keys) {
+  for (const key of keys) {
+    if (Object.hasOwn(env, key) && env[key] !== undefined)
+      return key;
+  }
+  return null;
+}
+function assertNoLegacyStorageMode(env = process.env) {
+  const legacyKey = firstDefinedEnvKey(env, LEGACY_STORAGE_MODE_KEYS);
+  if (!legacyKey)
+    return;
+  throw new Error(`${legacyKey} was removed. Deployment modes no longer exist: delete the storage-mode variable. ` + `The client uses the local SQLite store, or the HTTP API selected by ` + `HASNA_INSTRUCTIONS_API_URL + HASNA_INSTRUCTIONS_API_KEY. ` + `On the server, set HASNA_INSTRUCTIONS_DATABASE_URL to select the postgresql backend, ` + `or leave it unset for sqlite.`);
+}
+
+// src/lib/raw-store-root.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+var RAW_STORE_ROOT_ENV = "HASNA_CONFIGS_HOME";
+function getRawStoreRoot() {
+  return resolve(process.env[RAW_STORE_ROOT_ENV] || join(process.env["HOME"] || homedir(), ".hasna", "instructions"));
+}
+
+// src/db/database.ts
 function getDbPath() {
   if (process.env["HASNA_INSTRUCTIONS_DB_PATH"]) {
     return process.env["HASNA_INSTRUCTIONS_DB_PATH"];
   }
-  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-  const dir = join(home, ".hasna", "instructions");
+  const dir = getRawStoreRoot();
   mkdirSync(dir, { recursive: true });
-  return join(dir, "instructions.db");
+  return join2(dir, "instructions.db");
 }
 function uuid() {
   return randomUUID();
@@ -210,8 +240,9 @@ var _db = null;
 function getDatabase(path) {
   if (_db)
     return _db;
+  assertNoLegacyStorageMode();
   if (!path && process.env["HASNA_INSTRUCTIONS_API_URL"] && process.env["HASNA_INSTRUCTIONS_API_KEY"]) {
-    throw new Error("instructions is in self_hosted (cloud) mode: this command is not wired to the cloud API yet. " + "Unset HASNA_INSTRUCTIONS_API_URL / HASNA_INSTRUCTIONS_API_KEY to use it against the local store.");
+    throw new Error("instructions is using the HTTP API transport (HASNA_INSTRUCTIONS_API_URL set): this command is not wired to the API yet. " + "Unset HASNA_INSTRUCTIONS_API_URL / HASNA_INSTRUCTIONS_API_KEY to use it against the local store.");
   }
   const dbPath = path || getDbPath();
   const db = new Database(dbPath);
@@ -291,6 +322,34 @@ function insertFeedback(input, db) {
   d.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [input.message, input.email ?? null, input.category ?? "general", input.version ?? null]);
 }
 
+// src/db/snapshots.ts
+function createSnapshot(configId, content, version, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const ts = now();
+  d.run("INSERT INTO config_snapshots (id, config_id, content, version, created_at) VALUES (?, ?, ?, ?, ?)", [id, configId, content, version, ts]);
+  return { id, config_id: configId, content, version, created_at: ts };
+}
+function listSnapshots(configId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? ORDER BY version DESC").all(configId);
+}
+function getSnapshot(id, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE id = ?").get(id);
+}
+function getSnapshotByVersion(configId, version, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? AND version = ?").get(configId, version);
+}
+function pruneSnapshots(configId, keep = 10, db) {
+  const d = db || getDatabase();
+  const result = d.run(`DELETE FROM config_snapshots WHERE config_id = ? AND id NOT IN (
+      SELECT id FROM config_snapshots WHERE config_id = ? ORDER BY version DESC LIMIT ?
+    )`, [configId, configId, keep]);
+  return result.changes;
+}
+
 // src/db/configs.ts
 function rowToConfig(row) {
   let outputs = [];
@@ -329,25 +388,28 @@ function createConfig(input, db) {
   const slug = uniqueSlug(input.name, d);
   const tags = JSON.stringify(input.tags || []);
   const outputs = JSON.stringify(input.outputs || []);
-  d.run(`INSERT INTO configs (id, name, slug, kind, category, agent, target_path, outputs, format, content, description, tags, is_template, version, created_at, updated_at, synced_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, NULL)`, [
-    id,
-    input.name,
-    slug,
-    input.kind ?? "file",
-    input.category,
-    input.agent ?? "global",
-    input.target_path ?? null,
-    outputs,
-    input.format ?? "text",
-    input.content,
-    input.description ?? null,
-    tags,
-    input.is_template ? 1 : 0,
-    ts,
-    ts
-  ]);
-  return getConfig(id, d);
+  return d.transaction(() => {
+    d.run(`INSERT INTO configs (id, name, slug, kind, category, agent, target_path, outputs, format, content, description, tags, is_template, version, created_at, updated_at, synced_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, NULL)`, [
+      id,
+      input.name,
+      slug,
+      input.kind ?? "file",
+      input.category,
+      input.agent ?? "global",
+      input.target_path ?? null,
+      outputs,
+      input.format ?? "text",
+      input.content,
+      input.description ?? null,
+      tags,
+      input.is_template ? 1 : 0,
+      ts,
+      ts
+    ]);
+    createSnapshot(id, input.content, 1, d);
+    return getConfig(id, d);
+  })();
 }
 function getConfig(idOrSlug, db) {
   const d = db || getDatabase();
@@ -452,9 +514,13 @@ function updateConfig(idOrSlug, input, db) {
     updates.push("synced_at = ?");
     params.push(input.synced_at);
   }
-  params.push(existing.id);
-  d.run(`UPDATE configs SET ${updates.join(", ")} WHERE id = ?`, params);
-  return getConfigById(existing.id, d);
+  return d.transaction(() => {
+    params.push(existing.id);
+    d.run(`UPDATE configs SET ${updates.join(", ")} WHERE id = ?`, params);
+    const updated = getConfigById(existing.id, d);
+    createSnapshot(updated.id, updated.content, updated.version, d);
+    return updated;
+  })();
 }
 function deleteConfig(idOrSlug, db) {
   const d = db || getDatabase();
@@ -473,9 +539,9 @@ function getConfigStats(db) {
 }
 
 // src/lib/machine.ts
-import { arch as currentArch, homedir, hostname as currentHostname, type as currentOsType } from "os";
+import { arch as currentArch, homedir as homedir2, hostname as currentHostname, type as currentOsType } from "os";
 import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/lib/template.ts
 var VAR_PATTERN = /\{\{([A-Z0-9_]+)(?::([^}]*))?\}\}/g;
@@ -548,11 +614,11 @@ function normalizeOsFamily(os) {
   return value || "unknown";
 }
 function detectMachineContext(overrides = {}) {
-  const homeDir = overrides.home_dir ?? process.env["CONFIGS_HOME"] ?? process.env["HOME"] ?? homedir();
+  const homeDir = overrides.home_dir ?? process.env["CONFIGS_HOME"] ?? process.env["HOME"] ?? homedir2();
   const os = overrides.os ?? currentOsType();
   const osFamily = normalizeOsFamily(os);
-  const bunBinDir = overrides.bun_bin_dir ?? join2(homeDir, ".bun", "bin");
-  const defaultBunPath = osFamily === "macos" && existsSync2(BREW_BUN_PATH) ? BREW_BUN_PATH : join2(bunBinDir, "bun");
+  const bunBinDir = overrides.bun_bin_dir ?? join3(homeDir, ".bun", "bin");
+  const defaultBunPath = osFamily === "macos" && existsSync2(BREW_BUN_PATH) ? BREW_BUN_PATH : join3(bunBinDir, "bun");
   return {
     id: "current-machine",
     hostname: overrides.hostname ?? currentHostname(),
@@ -562,10 +628,10 @@ function detectMachineContext(overrides = {}) {
     created_at: "",
     os_family: osFamily,
     home_dir: homeDir,
-    workspace_root: overrides.workspace_root ?? join2(homeDir, osFamily === "macos" ? "Workspace" : "workspace"),
+    workspace_root: overrides.workspace_root ?? join3(homeDir, osFamily === "macos" ? "Workspace" : "workspace"),
     bun_bin_dir: bunBinDir,
     bun_path: overrides.bun_path ?? defaultBunPath,
-    path_prefix: overrides.path_prefix ?? (osFamily === "macos" ? `${join2("/opt", "homebrew", "bin")}:${bunBinDir}` : bunBinDir)
+    path_prefix: overrides.path_prefix ?? (osFamily === "macos" ? `${join3("/opt", "homebrew", "bin")}:${bunBinDir}` : bunBinDir)
   };
 }
 function machineContextToVariables(machine) {
@@ -679,13 +745,13 @@ function boundedReadPage(items, total, options = {}) {
 }
 
 // src/lib/instruction-graph.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 
 // src/lib/session-render.ts
-import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync3, realpathSync, statSync as statSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename as basename3, dirname as dirname2, extname as extname2, isAbsolute as isAbsolute3, join as join5, parse as parse2, posix as posix2, relative as relative2, resolve as resolve4 } from "path";
+import { createHash as createHash6 } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync, statSync as statSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename3, dirname as dirname2, extname as extname2, isAbsolute as isAbsolute3, join as join7, parse as parse2, posix as posix2, relative as relative2, resolve as resolve6 } from "path";
 
 // src/lib/global-agent-rules-standard.ts
 import { createHash } from "crypto";
@@ -989,213 +1055,213 @@ import {
   statSync,
   writeFileSync
 } from "fs";
-import { basename, dirname, isAbsolute, join as join3, parse, relative, resolve } from "path";
+import { basename, dirname, isAbsolute, join as join4, parse, relative, resolve as resolve2 } from "path";
 
-// node_modules/zod/v3/external.js
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
-  void: () => voidType,
-  util: () => util,
-  unknown: () => unknownType,
-  union: () => unionType,
-  undefined: () => undefinedType,
-  tuple: () => tupleType,
-  transformer: () => effectsType,
-  symbol: () => symbolType,
-  string: () => stringType,
-  strictObject: () => strictObjectType,
-  setErrorMap: () => setErrorMap,
-  set: () => setType,
-  record: () => recordType,
-  quotelessJson: () => quotelessJson,
-  promise: () => promiseType,
-  preprocess: () => preprocessType,
-  pipeline: () => pipelineType,
-  ostring: () => ostring,
-  optional: () => optionalType,
-  onumber: () => onumber,
-  oboolean: () => oboolean,
-  objectUtil: () => objectUtil,
-  object: () => objectType,
-  number: () => numberType,
-  nullable: () => nullableType,
-  null: () => nullType,
-  never: () => neverType,
-  nativeEnum: () => nativeEnumType,
-  nan: () => nanType,
-  map: () => mapType,
-  makeIssue: () => makeIssue,
-  literal: () => literalType,
-  lazy: () => lazyType,
-  late: () => late,
-  isValid: () => isValid,
-  isDirty: () => isDirty,
-  isAsync: () => isAsync,
-  isAborted: () => isAborted,
-  intersection: () => intersectionType,
-  instanceof: () => instanceOfType,
-  getParsedType: () => getParsedType,
-  getErrorMap: () => getErrorMap,
-  function: () => functionType,
-  enum: () => enumType,
-  effect: () => effectsType,
-  discriminatedUnion: () => discriminatedUnionType,
-  defaultErrorMap: () => en_default,
-  datetimeRegex: () => datetimeRegex,
-  date: () => dateType,
-  custom: () => custom,
-  coerce: () => coerce,
-  boolean: () => booleanType,
-  bigint: () => bigIntType,
-  array: () => arrayType,
-  any: () => anyType,
-  addIssueToContext: () => addIssueToContext,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransformer: () => ZodEffects,
-  ZodSymbol: () => ZodSymbol,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodSchema: () => ZodType,
-  ZodRecord: () => ZodRecord,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPipeline: () => ZodPipeline,
-  ZodParsedType: () => ZodParsedType,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNever: () => ZodNever,
-  ZodNativeEnum: () => ZodNativeEnum,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEffects: () => ZodEffects,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCatch: () => ZodCatch,
-  ZodBranded: () => ZodBranded,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigInt: () => ZodBigInt,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  Schema: () => ZodType,
-  ParseStatus: () => ParseStatus,
-  OK: () => OK,
-  NEVER: () => NEVER,
-  INVALID: () => INVALID,
-  EMPTY_PATH: () => EMPTY_PATH,
+  BRAND: () => BRAND,
   DIRTY: () => DIRTY,
-  BRAND: () => BRAND
-});
-
-// node_modules/zod/v3/helpers/util.js
-var util;
-(function(util2) {
-  util2.assertEqual = (_) => {};
-  function assertIs(_arg) {}
-  util2.assertIs = assertIs;
-  function assertNever(_x) {
-    throw new Error;
-  }
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
-    const obj = {};
-    for (const item of items) {
-      obj[item] = item;
-    }
-    return obj;
-  };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-      filtered[k] = obj[k];
-    }
-    return util2.objectValues(filtered);
-  };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
-      return obj[e];
-    });
-  };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
-    const keys = [];
-    for (const key in object) {
-      if (Object.prototype.hasOwnProperty.call(object, key)) {
-        keys.push(key);
-      }
-    }
-    return keys;
-  };
-  util2.find = (arr, checker) => {
-    for (const item of arr) {
-      if (checker(item))
-        return item;
-    }
-    return;
-  };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
-  function joinValues(array, separator = " | ") {
-    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
-  }
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  };
-})(util || (util = {}));
-var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
-    return {
-      ...first,
-      ...second
-    };
-  };
-})(objectUtil || (objectUtil = {}));
-var ZodParsedType = util.arrayToEnum([
-  "string",
-  "nan",
-  "number",
-  "integer",
-  "float",
-  "boolean",
-  "date",
-  "bigint",
-  "symbol",
-  "function",
-  "undefined",
-  "null",
-  "array",
-  "object",
-  "unknown",
-  "promise",
-  "void",
-  "never",
-  "map",
-  "set"
-]);
-var getParsedType = (data) => {
-  const t = typeof data;
-  switch (t) {
-    case "undefined":
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
+});
+
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
+var util;
+(function(util2) {
+  util2.assertEqual = (_) => {};
+  function assertIs(_arg) {}
+  util2.assertIs = assertIs;
+  function assertNever(_x) {
+    throw new Error;
+  }
+  util2.assertNever = assertNever;
+  util2.arrayToEnum = (items) => {
+    const obj = {};
+    for (const item of items) {
+      obj[item] = item;
+    }
+    return obj;
+  };
+  util2.getValidEnumValues = (obj) => {
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+    const filtered = {};
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
+    }
+    return util2.objectValues(filtered);
+  };
+  util2.objectValues = (obj) => {
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
+    });
+  };
+  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
+    const keys = [];
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  };
+  util2.find = (arr, checker) => {
+    for (const item of arr) {
+      if (checker(item))
+        return item;
+    }
+    return;
+  };
+  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
+  function joinValues(array, separator = " | ") {
+    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
+  }
+  util2.joinValues = joinValues;
+  util2.jsonStringifyReplacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+})(util || (util = {}));
+var objectUtil;
+(function(objectUtil2) {
+  objectUtil2.mergeShapes = (first, second) => {
+    return {
+      ...first,
+      ...second
+    };
+  };
+})(objectUtil || (objectUtil = {}));
+var ZodParsedType = util.arrayToEnum([
+  "string",
+  "nan",
+  "number",
+  "integer",
+  "float",
+  "boolean",
+  "date",
+  "bigint",
+  "symbol",
+  "function",
+  "undefined",
+  "null",
+  "array",
+  "object",
+  "unknown",
+  "promise",
+  "void",
+  "never",
+  "map",
+  "set"
+]);
+var getParsedType = (data) => {
+  const t = typeof data;
+  switch (t) {
+    case "undefined":
       return ZodParsedType.undefined;
     case "string":
       return ZodParsedType.string;
@@ -1234,7 +1300,7 @@ var getParsedType = (data) => {
   }
 };
 
-// node_modules/zod/v3/ZodError.js
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/ZodError.js
 var ZodIssueCode = util.arrayToEnum([
   "invalid_type",
   "invalid_literal",
@@ -1353,7 +1419,7 @@ ZodError.create = (issues) => {
   return error;
 };
 
-// node_modules/zod/v3/locales/en.js
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/locales/en.js
 var errorMap = (issue, _ctx) => {
   let message;
   switch (issue.code) {
@@ -1456,7 +1522,7 @@ var errorMap = (issue, _ctx) => {
 };
 var en_default = errorMap;
 
-// node_modules/zod/v3/errors.js
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/errors.js
 var overrideErrorMap = en_default;
 function setErrorMap(map) {
   overrideErrorMap = map;
@@ -1464,7 +1530,7 @@ function setErrorMap(map) {
 function getErrorMap() {
   return overrideErrorMap;
 }
-// node_modules/zod/v3/helpers/parseUtil.js
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
   const fullPath = [...path, ...issueData.path || []];
@@ -1570,14 +1636,14 @@ var isAborted = (x) => x.status === "aborted";
 var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
-// node_modules/zod/v3/helpers/errorUtil.js
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
-// node_modules/zod/v3/types.js
+// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 class ParseInputLazyPath {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -4969,7 +5035,7 @@ var SECRET_KEY_PATTERN = /^(.*_?API_?KEY|.*_?TOKEN|.*_?SECRET|.*_?PASSWORD|.*_?P
 var VALUE_PATTERNS = [
   { re: /npm_[A-Za-z0-9]{36,}/, reason: "npm token" },
   { re: /gh[pousr]_[A-Za-z0-9_]{36,}/, reason: "GitHub token" },
-  { re: /sk-ant-[A-Za-z0-9\-_]{40,}/, reason: "Anthropic API key" },
+  { re: /sk[-]ant-[A-Za-z0-9\-_]{40,}/, reason: "Anthropic API key" },
   { re: /sk-[A-Za-z0-9]{48,}/, reason: "OpenAI API key" },
   { re: /xoxb-[0-9]+-[A-Za-z0-9\-]+/, reason: "Slack bot token" },
   { re: /AIza[0-9A-Za-z\-_]{35}/, reason: "Google API key" },
@@ -5576,7 +5642,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" && resolve(file.path) === paths.target);
+  const plannedIndexes = input.files.filter((file) => file.role === "index" && resolve2(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");
   }
@@ -5634,7 +5700,7 @@ function withProjectContextSessionGuard(guard, action, options = {}) {
     verify();
     return action(null);
   }
-  const lockPath = resolve(validated.workspace_root, ...PROJECT_CONTEXT_LOCK_PATH.split("/"));
+  const lockPath = resolve2(validated.workspace_root, ...PROJECT_CONTEXT_LOCK_PATH.split("/"));
   const lock = acquireWorkspaceLock(validated.workspace_root, lockPath);
   try {
     verify();
@@ -5660,7 +5726,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 = resolve(observed.path);
+    const path = resolve2(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");
     }
@@ -5682,7 +5748,7 @@ function validateProjectContextSessionGuard(guard) {
 function applyProjectContext(options) {
   const workspaceRoot = assertSafeWorkspaceRoot(options.workspace_root);
   const now2 = options.now ?? new Date;
-  const lockPath = resolve(workspaceRoot, ...PROJECT_CONTEXT_LOCK_PATH.split("/"));
+  const lockPath = resolve2(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, now2);
@@ -5829,7 +5895,7 @@ function resolveBundleForApply(options, workspaceRoot, now2) {
   if (!options.expected_project_id) {
     throw new ProjectContextError("PROJECT_CONTEXT_CACHE_ID_REQUIRED", "expected_project_id is required for stale-cache fallback");
   }
-  const cachePath = resolve(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
+  const cachePath = resolve2(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");
@@ -6185,7 +6251,7 @@ function buildManifest(plan, now2) {
 function buildSessionCompatibilityManifest(plan, now2) {
   const paths = runtimePaths(plan.workspace_root, plan.runtime);
   const tool = manifestTool(plan.runtime);
-  const targetHome = plan.runtime === "codewith" ? resolve(plan.workspace_root, ".codewith") : plan.workspace_root;
+  const targetHome = plan.runtime === "codewith" ? resolve2(plan.workspace_root, ".codewith") : plan.workspace_root;
   const targetRelativePath = sessionTargetRelativePath(plan.runtime);
   const existing = existsSync3(paths.sessionManifest) ? readSessionManifestRecord(paths.sessionManifest, plan.workspace_root) : {
     schema: SESSION_RENDER_SCHEMA,
@@ -6207,7 +6273,7 @@ function buildSessionCompatibilityManifest(plan, now2) {
     throw new ProjectContextError("PROJECT_CONTEXT_MANIFEST_INVALID", "provider session manifest is malformed or incompatible");
   }
   const existingTargetHome = safeLegacyMetadataString(existing["targetHome"], null);
-  if (existingTargetHome !== null && resolve(existingTargetHome) !== targetHome) {
+  if (existingTargetHome !== null && resolve2(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");
@@ -6493,9 +6559,9 @@ function writeMetadataSnapshot(plan, now2) {
   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 = resolve(plan.workspace_root, ...PROJECT_CONTEXT_SNAPSHOT_DIR.split("/"));
+  const snapshotDir = resolve2(plan.workspace_root, ...PROJECT_CONTEXT_SNAPSHOT_DIR.split("/"));
   ensureSafeDirectory(snapshotDir, plan.workspace_root, 448);
-  const snapshotPath = resolve(snapshotDir, `${safeFilename(previous.projectContext.revision)}-${previous.projectContext.hash.slice(-12)}.json`);
+  const snapshotPath = resolve2(snapshotDir, `${safeFilename(previous.projectContext.revision)}-${previous.projectContext.hash.slice(-12)}.json`);
   const snapshot = {
     schema: "hasna.configs.session-render-snapshot/v1",
     kind: "project-context-metadata",
@@ -6511,8 +6577,8 @@ function writeMetadataSnapshot(plan, now2) {
   return snapshotPath;
 }
 function metadataSnapshotMatchesManifest(plan, manifest) {
-  const snapshotDir = resolve(plan.workspace_root, ...PROJECT_CONTEXT_SNAPSHOT_DIR.split("/"));
-  const snapshotPath = resolve(snapshotDir, `${safeFilename(manifest.projectContext.revision)}-${manifest.projectContext.hash.slice(-12)}.json`);
+  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 (!existsSync3(snapshotPath))
     return false;
   const record = readJsonRecord(snapshotPath, plan.workspace_root);
@@ -6561,10 +6627,10 @@ function writeProjectContextRollbackSnapshot(plan, now2, outputs) {
       sha256: nextHash
     };
   });
-  const snapshotDir = resolve(plan.workspace_root, ...SESSION_RENDER_SNAPSHOT_RELATIVE_DIR.split("/"));
+  const snapshotDir = resolve2(plan.workspace_root, ...SESSION_RENDER_SNAPSHOT_RELATIVE_DIR.split("/"));
   ensureSafeDirectory(snapshotDir, plan.workspace_root, 448);
   const timestamp = now2.toISOString().replace(/[:.]/g, "-");
-  const snapshotPath = resolve(snapshotDir, `${timestamp}-${randomUUID2()}.json`);
+  const snapshotPath = resolve2(snapshotDir, `${timestamp}-${randomUUID2()}.json`);
   const snapshot = {
     schema: "hasna.configs.session-render-snapshot/v2",
     createdAt: now2.toISOString(),
@@ -6629,7 +6695,7 @@ function readSessionManifestRecord(path, workspaceRoot) {
   }
 }
 function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash, afterExchange, atomicExchangeUnavailable = false, beforeInstall, portableCreateOnly = false, maxObservedBytes, allowPortableReplacement = false) {
-  const dir = resolve(path, "..");
+  const dir = resolve2(path, "..");
   ensureSafeDirectory(dir, workspaceRoot, 448);
   assertNoSymlinkSegments(workspaceRoot, path);
   const anchoredOps = portableCreateOnly ? null : resolveAnchoredFsOps();
@@ -6646,7 +6712,7 @@ function atomicWriteFile(path, content, workspaceRoot, defaultMode, expectedHash
   const previous = anchoredFileObservation(directory, targetName);
   const previousMode = previous?.mode ?? defaultMode;
   const tempName = `.project-context-${randomUUID2()}.tmp`;
-  const tempPath = join3(dir, tempName);
+  const tempPath = join4(dir, tempName);
   let fd = null;
   let preserveTemp = false;
   let directoryChanged = false;
@@ -6777,7 +6843,7 @@ function atomicWritePortable(path, content, workspaceRoot, defaultMode, expected
   }
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
-  const tempPath = join3(dir, `.project-context-${randomUUID2()}.tmp`);
+  const tempPath = join4(dir, `.project-context-${randomUUID2()}.tmp`);
   let fd = null;
   let tempIdentity = null;
   try {
@@ -6834,7 +6900,7 @@ function atomicWritePortableReplacement(path, content, workspaceRoot, expectedHa
   }
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
-  const tempPath = join3(dir, `.project-context-${randomUUID2()}.tmp`);
+  const tempPath = join4(dir, `.project-context-${randomUUID2()}.tmp`);
   const desiredHash = sha2562(content);
   let fd = null;
   let tempIdentity = null;
@@ -6903,11 +6969,11 @@ function portableFileHash(path, workspaceRoot, maxObservedBytes) {
   return createHash2("sha256").update(readFileSync(path)).digest("hex");
 }
 function writeProjectContextCoordinatedFile(input) {
-  atomicWriteFile(resolve(input.path), input.content, assertSafeWorkspaceRoot(input.workspace_root), input.default_mode ?? 420, input.expected_hash, undefined, false, input.test_hooks?.before_install, input.force_portable_file_ops ?? false, input.max_observed_bytes, input.allow_portable_replacement ?? false);
+  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);
 }
 function removeProjectContextCoordinatedFile(input) {
   const workspaceRoot = assertSafeWorkspaceRoot(input.workspace_root);
-  const path = resolve(input.path);
+  const path = resolve2(input.path);
   assertNoSymlinkSegments(workspaceRoot, path);
   const dir = dirname(path);
   const anchoredOps = input.force_portable_file_ops ? null : resolveAnchoredFsOps();
@@ -6933,7 +6999,7 @@ function removeProjectContextCoordinatedFile(input) {
       throw new ProjectContextHashRace(`managed path changed during deletion: ${relativePosix(workspaceRoot, path)}`);
     }
     displaced = true;
-    input.test_hooks?.after_displace?.(join3(dir, displacedName));
+    input.test_hooks?.after_displace?.(join4(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)}`);
@@ -6979,7 +7045,7 @@ function removePortableCoordinatedFile(path, workspaceRoot, expectedHash, maxObs
   }
   const dir = dirname(path);
   const directoryIdentity = captureManagedDirectoryIdentity(dir, workspaceRoot);
-  const displacedPath = join3(dir, `.project-context-delete-${randomUUID2()}.tmp`);
+  const displacedPath = join4(dir, `.project-context-delete-${randomUUID2()}.tmp`);
   let displaced = false;
   try {
     assertManagedDirectoryStable(dir, workspaceRoot, directoryIdentity);
@@ -7051,7 +7117,7 @@ function anchoredOpenExclusive(directory, name, mode) {
   const requestedMode = mode & 4095;
   let fd;
   try {
-    fd = openSync(join3(directory.path, name), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, requestedMode);
+    fd = openSync(join4(directory.path, name), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, requestedMode);
   } catch {
     throw new ProjectContextHashRace(`could not create prepared managed file in ${relativePosix(directory.workspaceRoot, directory.path)}`);
   }
@@ -7094,7 +7160,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, join3(directory.path, name));
+    const relativePath = relativePosix(directory.workspaceRoot, join4(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}`);
@@ -7120,7 +7186,7 @@ function anchoredPreparedObservation(directory, name, path, stage) {
   return observed;
 }
 function captureManagedDirectoryIdentity(path, workspaceRoot) {
-  assertNoSymlinkSegments(workspaceRoot, join3(path, ".project-context-directory-guard"));
+  assertNoSymlinkSegments(workspaceRoot, join4(path, ".project-context-directory-guard"));
   let stat;
   try {
     stat = lstatSync(path);
@@ -7133,7 +7199,7 @@ function captureManagedDirectoryIdentity(path, workspaceRoot) {
   return { dev: stat.dev, ino: stat.ino };
 }
 function assertManagedDirectoryStable(path, workspaceRoot, expected) {
-  assertNoSymlinkSegments(workspaceRoot, join3(path, ".project-context-directory-guard"));
+  assertNoSymlinkSegments(workspaceRoot, join4(path, ".project-context-directory-guard"));
   let current;
   try {
     current = lstatSync(path);
@@ -7268,10 +7334,10 @@ function resolveAnchoredFsOps() {
   return null;
 }
 function acquireWorkspaceLock(workspaceRoot, lockPath, afterOpen, beforeStaleRemove, processStartIdentityLookup = processStartIdentity) {
-  const lockDirectory = resolve(lockPath, "..");
+  const lockDirectory = resolve2(lockPath, "..");
   ensureSafeDirectory(lockDirectory, workspaceRoot, 448);
   assertNoSymlinkSegments(workspaceRoot, lockPath);
-  const tempPath = join3(lockDirectory, `.project-context-lock-${randomUUID2()}.tmp`);
+  const tempPath = join4(lockDirectory, `.project-context-lock-${randomUUID2()}.tmp`);
   let fd = null;
   let openedIdentity = null;
   let openedContentHash = null;
@@ -7343,7 +7409,7 @@ function removeOwnedLockByInode(lockPath, identity, expectedHash) {
     if (expectedHash !== undefined && sha2562(readFileSync(lockPath, "utf8")) !== expectedHash)
       return;
     rmSync2(lockPath);
-    fsyncDirectory(resolve(lockPath, ".."));
+    fsyncDirectory(resolve2(lockPath, ".."));
   } catch {}
 }
 function observeStaleWorkspaceLock(lockPath, workspaceRoot, processStartIdentityLookup = processStartIdentity) {
@@ -7422,7 +7488,7 @@ 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(resolve(lockPath, ".."));
+    fsyncDirectory(resolve2(lockPath, ".."));
     exchanged = false;
     return true;
   } catch (error) {
@@ -7501,8 +7567,8 @@ function releaseWorkspaceLock(lockPath, lock, workspaceRoot) {
     }
     return;
   }
-  const lockDirectory = resolve(lockPath, "..");
-  const releasePath = join3(lockDirectory, `.project-context-release-${randomUUID2()}.tmp`);
+  const lockDirectory = resolve2(lockPath, "..");
+  const releasePath = join4(lockDirectory, `.project-context-release-${randomUUID2()}.tmp`);
   let releaseFd = null;
   let releaseIdentity = null;
   let releaseHash = null;
@@ -7582,7 +7648,7 @@ function ensureSafeDirectory(path, workspaceRoot, mode) {
   const segments = rel.split(/[\\/]+/).filter(Boolean);
   let current = workspaceRoot;
   for (const segment of segments) {
-    current = join3(current, segment);
+    current = join4(current, segment);
     if (existsSync3(current)) {
       if (lstatSync(current).isSymbolicLink())
         throw new ProjectContextError("PROJECT_CONTEXT_SYMLINK_REJECTED", `managed path uses a symlink: ${current}`);
@@ -7590,7 +7656,7 @@ function ensureSafeDirectory(path, workspaceRoot, mode) {
         throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", `managed path is not a directory: ${current}`);
     } else {
       mkdirSync2(current, { mode });
-      fsyncDirectory(resolve(current, ".."));
+      fsyncDirectory(resolve2(current, ".."));
     }
   }
 }
@@ -7646,11 +7712,11 @@ function scanGeneratedContent(content) {
 function runtimePaths(workspaceRoot, runtime) {
   const relativeTarget = runtime === "claude" ? "CLAUDE.md" : runtime === "codewith" ? ".codewith/CODEWITH.md" : "AGENTS.md";
   return {
-    target: resolve(workspaceRoot, ...relativeTarget.split("/")),
-    fragment: resolve(workspaceRoot, ...PROJECT_CONTEXT_FRAGMENT_PATH.split("/")),
-    manifest: resolve(workspaceRoot, ...PROJECT_CONTEXT_MANIFEST_PATH.split("/")),
-    cache: resolve(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/")),
-    sessionManifest: runtime === "codewith" ? resolve(workspaceRoot, ".codewith", ".hasna", "session-render-manifest.json") : resolve(workspaceRoot, ".hasna", "session-render-manifest.json")
+    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")
   };
 }
 function projectContextSessionGuardPaths(paths, runtime) {
@@ -7660,7 +7726,7 @@ function projectContextSessionGuardPaths(paths, runtime) {
     paths.fragment,
     paths.target,
     paths.sessionManifest,
-    ...runtime === "codewith" ? [resolve(paths.target, "..", "CODEWITH.override.md")] : []
+    ...runtime === "codewith" ? [resolve2(paths.target, "..", "CODEWITH.override.md")] : []
   ];
 }
 function sessionTargetRelativePath(runtime) {
@@ -7680,12 +7746,12 @@ function projectContextRuntimeForSessionTool(tool) {
   return null;
 }
 function projectContextWorkspaceForSession(input, runtime) {
-  const targetHome = resolve(input.target_home);
+  const targetHome = resolve2(input.target_home);
   if (runtime === "codewith") {
     const workspaceRoot = basename(targetHome) === ".codewith" ? dirname(targetHome) : null;
     if (!workspaceRoot)
       return null;
-    if (input.project_root && resolve(input.project_root) !== workspaceRoot) {
+    if (input.project_root && resolve2(input.project_root) !== workspaceRoot) {
       throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", "Codewith project_root must be the parent workspace of target_home");
     }
     if (!existsSync3(workspaceRoot) || !lstatSync(workspaceRoot).isDirectory())
@@ -7699,7 +7765,7 @@ function projectContextWorkspaceForSession(input, runtime) {
 function assertCodewithTargetIsConsumed(workspaceRoot, runtime) {
   if (runtime !== "codewith")
     return;
-  const override = resolve(workspaceRoot, ".codewith", "CODEWITH.override.md");
+  const override = resolve2(workspaceRoot, ".codewith", "CODEWITH.override.md");
   if (!existsSync3(override))
     return;
   assertNoSymlinkSegments(workspaceRoot, override);
@@ -7710,7 +7776,7 @@ function assertCodewithTargetIsConsumed(workspaceRoot, runtime) {
 function assertSafeWorkspaceRoot(path) {
   if (!isAbsolute(path))
     throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", "workspace root must be absolute");
-  const normalized = resolve(path);
+  const normalized = resolve2(path);
   if (normalized === parse(normalized).root)
     throw new ProjectContextError("PROJECT_CONTEXT_PATH_INVALID", "workspace root cannot be the filesystem root");
   if (!existsSync3(normalized) || !lstatSync(normalized).isDirectory())
@@ -7727,17 +7793,17 @@ function assertNoSymlinkSegments(root, target) {
   }
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join3(current, segment);
+    current = join4(current, segment);
     if (existsSync3(current) && lstatSync(current).isSymbolicLink()) {
       throw new ProjectContextError("PROJECT_CONTEXT_SYMLINK_REJECTED", `managed path uses a symlink: ${current}`);
     }
   }
 }
 function assertNoSymlinkAncestors(path) {
-  const normalized = resolve(path);
+  const normalized = resolve2(path);
   let current = parse(normalized).root;
   for (const segment of relative(current, normalized).split(/[\\/]+/).filter(Boolean)) {
-    current = join3(current, segment);
+    current = join4(current, segment);
     if (!existsSync3(current))
       return;
     if (lstatSync(current).isSymbolicLink())
@@ -7773,10 +7839,10 @@ function fragmentMatchesBundle(path, bundle, workspaceRoot) {
 }
 function durableSourcePath(path, workspaceRoot) {
   if (!path || path.startsWith("/dev/fd/"))
-    return resolve(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
-  const normalized = isAbsolute(path) ? resolve(path) : resolve(workspaceRoot, path);
+    return resolve2(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
+  const normalized = isAbsolute(path) ? resolve2(path) : resolve2(workspaceRoot, path);
   if (normalized.startsWith("/dev/fd/"))
-    return resolve(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
+    return resolve2(workspaceRoot, ...PROJECT_CONTEXT_CACHE_PATH.split("/"));
   return normalized;
 }
 function compareRevisions(incoming, previous) {
@@ -8074,7 +8140,7 @@ function applyTransform(source, output, context = {}) {
 
 // src/lib/asset-plan.ts
 import { createHash as createHash3 } from "crypto";
-import { isAbsolute as isAbsolute2, posix, resolve as resolve2 } from "path";
+import { isAbsolute as isAbsolute2, posix, resolve as resolve3 } from "path";
 
 // src/lib/provider-version.ts
 function providerVersionSatisfies(version, range) {
@@ -8384,8 +8450,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 = resolve2(root, ...relativePath.split("/"));
-  const normalizedRoot = resolve2(root);
+  const target = resolve3(root, ...relativePath.split("/"));
+  const normalizedRoot = resolve3(root);
   if (target === normalizedRoot)
     throw new Error(`Asset ${item.assetKey} destination cannot replace its root.`);
   if (!target.startsWith(`${normalizedRoot}/`))
@@ -8507,8 +8573,8 @@ function deepFreeze(value) {
 // src/lib/cursor-authority.ts
 import { createHash as createHash4 } from "crypto";
 import { lstatSync as lstatSync2, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join4, resolve as resolve3 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join5, resolve as resolve4 } from "path";
 var CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH = ".cursor/rules/hasna-global.mdc";
 var CURSOR_GLOBAL_AUTHORITY_MAX_BYTES = 256 * 1024;
 var CURSOR_GLOBAL_AUTHORITY_MANAGED_MARKER = "Managed by @hasna/configs cursor global authority";
@@ -8518,7 +8584,7 @@ function sha2564(content) {
   return createHash4("sha256").update(content).digest("hex");
 }
 function homeDir() {
-  return process.env["HOME"] || homedir2();
+  return process.env["HOME"] || homedir3();
 }
 function markerPayload(content, markerLine, markerIndex) {
   const index = markerIndex ?? content.indexOf(markerLine);
@@ -8534,12 +8600,12 @@ function baseObservation(path) {
   };
 }
 function observeCursorGlobalAuthority(options = {}) {
-  const authorityPath = resolve3(join4(options.home ?? homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
+  const authorityPath = resolve4(join5(options.home ?? homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
   const readFile = options.readFile ?? ((path) => readFileSync2(path, "utf8"));
   return observeCursorGlobalAuthorityPath(authorityPath, readFile);
 }
 function observeCursorGlobalAuthorityAtPath(authorityPath) {
-  return observeCursorGlobalAuthorityPath(resolve3(authorityPath), (path) => readFileSync2(path, "utf8"));
+  return observeCursorGlobalAuthorityPath(resolve4(authorityPath), (path) => readFileSync2(path, "utf8"));
 }
 function observeCursorGlobalAuthorityPath(authorityPath, readFile) {
   const base = baseObservation(authorityPath);
@@ -8684,7 +8750,7 @@ function observeCursorGlobalAuthorityPath(authorityPath, readFile) {
   };
 }
 function isCursorGlobalAuthorityPath(path) {
-  return resolve3(path) === resolve3(join4(homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
+  return resolve4(path) === resolve4(join5(homeDir(), CURSOR_GLOBAL_AUTHORITY_RELATIVE_PATH));
 }
 function stampCursorGlobalAuthorityMarker(content) {
   if (CURSOR_GLOBAL_AUTHORITY_MARKER_PATTERN.test(content))
@@ -8721,8 +8787,82 @@ function detectCursorAuthorityConflicts(observation = observeCursorGlobalAuthori
   }];
 }
 
+// src/lib/session-authority.ts
+import { createHash as createHash5 } from "crypto";
+import { lstatSync as lstatSync3, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { join as join6, resolve as resolve5 } from "path";
+var CLAUDE_LEGACY_AUTHORITY_RELATIVE_PATH = "AGENTS.md";
+var CLAUDE_LEGACY_AUTHORITY_MAX_BYTES = 256 * 1024;
+var CLAUDE_LEGACY_MARKERS = [
+  { id: "claude-agent-rules-heading", pattern: /^# Agent Rules \(Claude\)/m },
+  { id: "no-worktrees-heading", pattern: /^## No Worktrees/m },
+  { id: "no-worktrees-directive", pattern: /\bNever use git worktrees\b/m }
+];
+function sha2565(content) {
+  return createHash5("sha256").update(content).digest("hex");
+}
+function detectClaudeAuthorityConflicts(targetHome) {
+  const authorityPath = resolve5(join6(targetHome, CLAUDE_LEGACY_AUTHORITY_RELATIVE_PATH));
+  let stat;
+  try {
+    stat = lstatSync3(authorityPath);
+  } catch {
+    return [];
+  }
+  const provenanceBase = {
+    tool: "claude",
+    relativePath: CLAUDE_LEGACY_AUTHORITY_RELATIVE_PATH,
+    path: authorityPath
+  };
+  if (stat.isSymbolicLink() || !stat.isFile()) {
+    return [{
+      ...provenanceBase,
+      kind: "invalid-unmanaged-authority",
+      sha256: null,
+      markers: [],
+      provenance: {
+        source: "filesystem",
+        authority: "unmanaged",
+        observedPath: authorityPath,
+        detection: "non-regular-file"
+      },
+      reason: "Claude target contains unmanaged AGENTS.md that is not a regular file; authority cannot be verified safely."
+    }];
+  }
+  if (statSync2(authorityPath).size > CLAUDE_LEGACY_AUTHORITY_MAX_BYTES) {
+    return [{
+      ...provenanceBase,
+      kind: "invalid-unmanaged-authority",
+      sha256: null,
+      markers: [],
+      provenance: {
+        source: "filesystem",
+        authority: "unmanaged",
+        observedPath: authorityPath,
+        detection: "oversized-file"
+      },
+      reason: `Claude target contains unmanaged AGENTS.md larger than ${CLAUDE_LEGACY_AUTHORITY_MAX_BYTES} bytes; authority cannot be classified safely.`
+    }];
+  }
+  const content = readFileSync3(authorityPath, "utf8");
+  const markers = CLAUDE_LEGACY_MARKERS.filter((marker) => marker.pattern.test(content)).map((marker) => marker.id);
+  const knownLegacy = markers.includes("no-worktrees-heading") && markers.includes("no-worktrees-directive");
+  return [{
+    ...provenanceBase,
+    kind: knownLegacy ? "known-legacy-no-worktree" : "unknown-unmanaged-authority",
+    sha256: sha2565(content),
+    markers,
+    provenance: {
+      source: "filesystem",
+      authority: "unmanaged",
+      observedPath: authorityPath,
+      detection: knownLegacy ? "known-legacy-markers" : "unknown-content"
+    },
+    reason: knownLegacy ? "Claude target contains unmanaged legacy AGENTS.md with no-worktree directives; migrate or remove it through an owned authority path before applying." : "Claude target contains unmanaged AGENTS.md with unknown authority content; refusing to guess whether it conflicts with the managed Claude render."
+  }];
+}
+
 // src/lib/session-render.ts
-var RAW_STORE_ROOT_ENV = "HASNA_CONFIGS_HOME";
 var ANTIGRAVITY_RULE_FILE_CHAR_LIMIT = 12000;
 var SESSION_RENDERER_OWNER_ID = "instructions-session-renderer";
 var SESSION_RENDER_TOOLS = [
@@ -8934,11 +9074,11 @@ function ensureTrailingNewline3(content) {
 `) ? content : `${content}
 `;
 }
-function sha2565(content) {
-  return createHash5("sha256").update(content).digest("hex");
+function sha2566(content) {
+  return createHash6("sha256").update(content).digest("hex");
 }
 function fingerprint(value) {
-  return sha2565(JSON.stringify(value));
+  return sha2566(JSON.stringify(value));
 }
 function canonicalFingerprintValue(value) {
   if (Array.isArray(value))
@@ -8956,7 +9096,7 @@ function ruleAttestation(rule) {
   };
   const applied = metadata["payloadFloorApplied"];
   return {
-    contentSha256: sha2565(rule.content ?? ""),
+    contentSha256: sha2566(rule.content ?? ""),
     payloadFloorApplied: typeof applied === "boolean" ? applied : null,
     flooredFromRulesVersion: read("flooredFromRulesVersion"),
     flooredFromPayloadSha256: read("flooredFromPayloadSha256"),
@@ -9002,16 +9142,14 @@ function slug(value) {
 function yamlQuote2(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
 }
-function getRawStoreRoot() {
-  return resolve4(process.env[RAW_STORE_ROOT_ENV] || join5(process.env["HOME"] || homedir3(), ".hasna", "configs"));
-}
 function defaultTargetHome(tool, profile, sessionId) {
-  return join5(getRawStoreRoot(), "sessions", tool, slug(profile), slug(sessionId || "latest"));
+  const home = process.env["HOME"] || homedir4();
+  return join7(home, ".hasna", "accounts", "profiles", tool, slug(profile));
 }
 function joinTarget(targetHome, relativePath) {
   const safeTargetHome = assertSafeTargetRoot(targetHome);
   const safeRelativePath2 = assertSafeRelativePath(relativePath);
-  return join5(safeTargetHome, ...safeRelativePath2.split("/"));
+  return join7(safeTargetHome, ...safeRelativePath2.split("/"));
 }
 function makeFile(targetHome, relativePath, role, content, sourceIds) {
   const safeTargetHome = assertSafeTargetRoot(targetHome);
@@ -9022,7 +9160,7 @@ function makeFile(targetHome, relativePath, role, content, sourceIds) {
     relativePath: safeRelativePath2,
     role,
     content: normalizedContent,
-    sha256: sha2565(normalizedContent),
+    sha256: sha2566(normalizedContent),
     sourceIds
   };
 }
@@ -9056,7 +9194,7 @@ function applyAgentOperatingRulesFloor(source, content) {
   const floored = {
     payloadFloorApplied: true,
     flooredFromRulesVersion: parseAgentOperatingRulesVersion(content),
-    flooredFromPayloadSha256: sha2565(content)
+    flooredFromPayloadSha256: sha2566(content)
   };
   return {
     content: payload.content,
@@ -9078,7 +9216,7 @@ function applyAgentOperatingRulesFloorToRule(source, rule, content) {
   const floored = {
     payloadFloorApplied: true,
     flooredFromRulesVersion: parseAgentOperatingRulesVersion(content),
-    flooredFromPayloadSha256: sha2565(content)
+    flooredFromPayloadSha256: sha2566(content)
   };
   return {
     content: payload.content,
@@ -9097,7 +9235,7 @@ function skippedSource(source, reason) {
       order: source.resolvedOrder,
       path: source.path ?? null,
       hash: source.hash ?? null,
-      renderedPayloadSha256: sha2565(source.content),
+      renderedPayloadSha256: sha2566(source.content),
       nonOverridable: source.nonOverridable === true,
       provenance: source.provenance ?? null
     }
@@ -9139,7 +9277,7 @@ function compareSessionInstructionSources(a, b) {
   return SESSION_LAYER_RANK[a.resolvedLayer] - SESSION_LAYER_RANK[b.resolvedLayer] || a.resolvedOrder - b.resolvedOrder || a.id.localeCompare(b.id);
 }
 function semanticPolicyIntegrity(body) {
-  return sha2565(body) === AGENT_OPERATING_RULES_PAYLOAD_SHA256 ? "pinned-digest" : "unverified-self-declared";
+  return sha2566(body) === AGENT_OPERATING_RULES_PAYLOAD_SHA256 ? "pinned-digest" : "unverified-self-declared";
 }
 function semanticPolicyDeclaration(source) {
   const normalize = (value) => value.replace(/\r\n/g, `
@@ -9364,7 +9502,7 @@ function composeSources(sources, tool) {
             targetSourceId: target.id,
             targetNormalizedSourceId: target.normalizedId,
             targetHash: target.hash ?? null,
-            targetRenderedPayloadSha256: sha2565(target.content),
+            targetRenderedPayloadSha256: sha2566(target.content),
             targetNonOverridable: protectedReplacement,
             authority: protectedReplacement ? "canonical-identity-export/codewith-provider/v1" : "overridable-source/v1"
           }
@@ -9546,7 +9684,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 = existsSync4(existingConfigPath) ? readOpenCodeConfig(readFileSync3(existingConfigPath, "utf8"), existingConfigPath) : providerConfig ? readOpenCodeConfig(providerConfig.content, providerConfig.sourceId) : {};
+  const selectedConfig = existsSync4(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,
@@ -9695,7 +9833,7 @@ function buildAssetFiles(input, targetHome, blocked) {
       relativePath: assertSafeRelativePath(relativePath),
       role: "asset",
       content,
-      sha256: sha2565(content),
+      sha256: sha2566(content),
       sourceIds: [item.sourceConfigId, item.assetId]
     };
   });
@@ -9735,7 +9873,7 @@ function adapterFor(input) {
   return gatedNativeImports ? CODEWITH_NATIVE_ADAPTER : CODEWITH_FLATTENED_ADAPTER;
 }
 function getHomeDir() {
-  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir3();
+  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir4();
 }
 function cleanSessionPathInput(path) {
   const trimmed = path.trim();
@@ -9750,16 +9888,16 @@ function resolveSessionPath(path) {
     throw new Error("Session render path cannot be empty.");
   const home = getHomeDir();
   if (cleaned === "~")
-    return resolve4(home);
+    return resolve6(home);
   if (cleaned.startsWith("~/"))
-    return resolve4(home, cleaned.slice(2));
+    return resolve6(home, cleaned.slice(2));
   if (cleaned === "{{HOME}}" || cleaned === "${HOME}")
-    return resolve4(home);
+    return resolve6(home);
   if (cleaned.startsWith("{{HOME}}/"))
-    return resolve4(home, cleaned.slice("{{HOME}}/".length));
+    return resolve6(home, cleaned.slice("{{HOME}}/".length));
   if (cleaned.startsWith("${HOME}/"))
-    return resolve4(home, cleaned.slice("${HOME}/".length));
-  return resolve4(cleaned);
+    return resolve6(home, cleaned.slice("${HOME}/".length));
+  return resolve6(cleaned);
 }
 function assertSafeRelativePath(relativePath) {
   if (!relativePath.trim())
@@ -9775,7 +9913,7 @@ function assertSafeRelativePath(relativePath) {
 function assertSafeTargetRoot(targetHome) {
   if (!isAbsolute3(targetHome))
     throw new Error(`Session render target must be an absolute path: ${targetHome}`);
-  const normalized = resolve4(targetHome);
+  const normalized = resolve6(targetHome);
   if (normalized === parse2(normalized).root) {
     throw new Error(`Session render target cannot be the filesystem root: ${targetHome}`);
   }
@@ -9873,7 +10011,7 @@ function planSessionRender(input) {
     blockers: targetBlockers
   } = resolveRenderTarget(input);
   const authorityObservations = input.tool === "cursor" && targetKind !== "blocked" ? [observeCursorGlobalAuthority({ home: input.cursorAuthorityHome })] : [];
-  const authorityConflicts = input.tool === "cursor" && targetKind !== "blocked" ? detectCursorAuthorityConflicts(authorityObservations[0]) : [];
+  const authorityConflicts = input.tool === "cursor" && targetKind !== "blocked" ? detectCursorAuthorityConflicts(authorityObservations[0]) : input.tool === "claude" && targetKind !== "blocked" ? detectClaudeAuthorityConflicts(targetHome) : [];
   const blockers = [
     ...targetBlockers,
     ...authorityConflicts.map((conflict) => `${conflict.relativePath}: ${conflict.reason}`)
@@ -9971,7 +10109,7 @@ function planSessionRender(input) {
           hash: rule.hash ?? null,
           ...ruleAttestation(rule)
         })),
-        renderedPayloadSha256: sha2565(source.content),
+        renderedPayloadSha256: sha2566(source.content),
         provenance: source.provenance ?? null,
         metadata: source.metadata ?? null
       })),
@@ -10009,8 +10147,8 @@ function planSessionRender(input) {
     ...input.providerConfig ? {
       providerConfig: {
         sourceId: input.providerConfig.sourceId,
-        selectedPayloadSha256: sha2565(input.providerConfig.content),
-        renderedPayloadSha256: files.find((file) => file.relativePath === adapter.configFile)?.sha256 ?? sha2565(input.providerConfig.content),
+        selectedPayloadSha256: sha2566(input.providerConfig.content),
+        renderedPayloadSha256: files.find((file) => file.relativePath === adapter.configFile)?.sha256 ?? sha2566(input.providerConfig.content),
         selected: !existsSync4(joinTarget(targetHome, adapter.configFile))
       }
     } : {},
@@ -10118,7 +10256,7 @@ function selectProfileConfigsForSessionRender(configs, tool) {
   const selectedSources = [];
   const equivalentSources = new Map;
   for (const candidate of sources) {
-    const key = sha2565(candidate.source.content);
+    const key = sha2566(candidate.source.content);
     const existing = equivalentSources.get(key);
     if (!existing) {
       equivalentSources.set(key, {
@@ -10397,7 +10535,7 @@ function readIdentitySourcePath(sourcePath, baseDir, sourceId) {
     }
     return;
   }
-  const stat = statSync2(resolvedPath);
+  const stat = statSync3(resolvedPath);
   if (!stat.isFile()) {
     throw new Error(`Identity instruction source path is not a file for ${sourceId}: ${sourcePath.path}`);
   }
@@ -10406,7 +10544,7 @@ function readIdentitySourcePath(sourcePath, baseDir, sourceId) {
   if (!pathIsInside(realPath, realBase)) {
     throw new Error(`Identity instruction source path escapes export directory for ${sourceId}: ${sourcePath.path}`);
   }
-  return readFileSync3(realPath, "utf-8");
+  return readFileSync4(realPath, "utf-8");
 }
 function resolveIdentitySourcePath(path, baseDir, sourceId) {
   const cleaned = cleanSessionPathInput(path);
@@ -10414,8 +10552,8 @@ function resolveIdentitySourcePath(path, baseDir, sourceId) {
     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) ? resolve4(cleaned) : resolve4(baseDir, cleaned);
-  if (!pathIsInside(resolvedPath, resolve4(baseDir))) {
+  const resolvedPath = isAbsolute3(cleaned) ? resolve6(cleaned) : resolve6(baseDir, cleaned);
+  if (!pathIsInside(resolvedPath, resolve6(baseDir))) {
     throw new Error(`Identity instruction source path escapes export directory for ${sourceId}: ${path}`);
   }
   return resolvedPath;
@@ -10811,7 +10949,7 @@ function compileInstructionGraph(input) {
       effective_activation: effective.get(configId),
       fallback: row.binding.fallback,
       required: row.binding.required,
-      content_sha256: sha2566(config.content),
+      content_sha256: sha2567(config.content),
       dependencies: dependencies.get(configId) ?? []
     };
   });
@@ -10848,7 +10986,7 @@ function compileInstructionGraph(input) {
     diagnostics
   };
   return {
-    plan: deepFreeze2({ ...planWithoutHash, source_hash: sha2566(stableJson2(planWithoutHash)) }),
+    plan: deepFreeze2({ ...planWithoutHash, source_hash: sha2567(stableJson2(planWithoutHash)) }),
     sources,
     capability: capability2
   };
@@ -11031,8 +11169,8 @@ class InstructionGraphValidationError extends Error {
     this.name = "InstructionGraphValidationError";
   }
 }
-function sha2566(value) {
-  return createHash6("sha256").update(value).digest("hex");
+function sha2567(value) {
+  return createHash7("sha256").update(value).digest("hex");
 }
 function stableJson2(value) {
   const canonical = (entry) => Array.isArray(entry) ? entry.map(canonical) : entry && typeof entry === "object" ? Object.fromEntries(Object.entries(entry).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, canonical(child)])) : entry;
@@ -11251,34 +11389,6 @@ function resolveProfileForMachineRead(machine = detectMachineContext(), options
   };
 }
 
-// src/db/snapshots.ts
-function createSnapshot(configId, content, version, db) {
-  const d = db || getDatabase();
-  const id = uuid();
-  const ts = now();
-  d.run("INSERT INTO config_snapshots (id, config_id, content, version, created_at) VALUES (?, ?, ?, ?, ?)", [id, configId, content, version, ts]);
-  return { id, config_id: configId, content, version, created_at: ts };
-}
-function listSnapshots(configId, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? ORDER BY version DESC").all(configId);
-}
-function getSnapshot(id, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM config_snapshots WHERE id = ?").get(id);
-}
-function getSnapshotByVersion(configId, version, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? AND version = ?").get(configId, version);
-}
-function pruneSnapshots(configId, keep = 10, db) {
-  const d = db || getDatabase();
-  const result = d.run(`DELETE FROM config_snapshots WHERE config_id = ? AND id NOT IN (
-      SELECT id FROM config_snapshots WHERE config_id = ? ORDER BY version DESC LIMIT ?
-    )`, [configId, configId, keep]);
-  return result.changes;
-}
-
 // src/db/machines.ts
 import { arch, hostname, type } from "os";
 function currentHostname2() {
@@ -11358,16 +11468,17 @@ function parseBoundedOrLegacyPage(value, legacyItems, options, label) {
 var API_URL_ENV = "HASNA_INSTRUCTIONS_API_URL";
 var API_KEY_ENV = "HASNA_INSTRUCTIONS_API_KEY";
 function resolveCloudConfig(env = process.env) {
+  assertNoLegacyStorageMode(env);
   const apiUrl = env[API_URL_ENV]?.trim();
   const apiKey = env[API_KEY_ENV]?.trim();
   if (!apiUrl && !apiKey)
     return null;
   if (!apiUrl || !apiKey) {
-    throw new Error(`API mode requires BOTH ${API_URL_ENV} and ${API_KEY_ENV}; only ` + `${apiUrl ? API_URL_ENV : API_KEY_ENV} is set. Set both to use the cloud API, ` + `or unset both to use the local store.`);
+    throw new Error(`API mode requires BOTH ${API_URL_ENV} and ${API_KEY_ENV}; only ` + `${apiUrl ? API_URL_ENV : API_KEY_ENV} is set. Set both to use the HTTP API, ` + `or unset both to use the local store.`);
   }
   return { apiUrl, apiKey };
 }
-function isCloudMode(env = process.env) {
+function isApiTransport(env = process.env) {
   return resolveCloudConfig(env) !== null;
 }
 
@@ -11844,16 +11955,16 @@ function resolveConfigStore(env = process.env) {
   return cloud ? new CloudConfigStore(cloud) : new LocalConfigStore;
 }
 // src/status.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
 
 // src/lib/apply.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename4, dirname as dirname4, join as join7, resolve as resolve5 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, realpathSync as realpathSync2, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename4, dirname as dirname4, join as join9, resolve as resolve7 } from "path";
+import { homedir as homedir5 } from "os";
 
 // src/lib/session-render-ownership.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
-import { dirname as dirname3, join as join6, parse as parse3, relative as relative3, sep } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, statSync as statSync4 } from "fs";
+import { dirname as dirname3, join as join8, parse as parse3, relative as relative3, sep } from "path";
 var MANIFEST_ANCESTOR_LIMIT = 24;
 var MANAGED_PATH_SEGMENTS = SESSION_RENDER_EXCLUSIVE_MANAGED_PATHS.map((managedPath) => managedPath.split("/").filter(Boolean));
 var manifestCache = new Map;
@@ -11877,7 +11988,7 @@ function readManifestRelativePaths(manifestPath) {
   try {
     if (!existsSync5(manifestPath))
       return null;
-    stats = statSync3(manifestPath);
+    stats = statSync4(manifestPath);
   } catch {
     return null;
   }
@@ -11887,7 +11998,7 @@ function readManifestRelativePaths(manifestPath) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+    manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
   } catch {
     return null;
   }
@@ -11904,7 +12015,7 @@ function sessionRenderManifestClaimsPath(absolutePath2) {
   const root = parse3(absolutePath2).root;
   let home = dirname3(absolutePath2);
   for (let depth = 0;depth < MANIFEST_ANCESTOR_LIMIT; depth += 1) {
-    const manifestPath = join6(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
+    const manifestPath = join8(home, ...SESSION_RENDER_MANIFEST_RELATIVE_PATH.split("/"));
     const relativePaths = readManifestRelativePaths(manifestPath);
     if (relativePaths) {
       const claimed = relative3(home, absolutePath2).split(sep).join("/");
@@ -11924,13 +12035,13 @@ function sessionRenderOwnsPath(absolutePath2) {
 
 // src/lib/apply.ts
 function getConfigHome() {
-  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir4();
+  return process.env["CONFIGS_HOME"] || process.env["HOME"] || homedir5();
 }
 function expandPath(p) {
   if (p.startsWith("~/")) {
-    return resolve5(getConfigHome(), p.slice(2));
+    return resolve7(getConfigHome(), p.slice(2));
   }
-  return resolve5(p);
+  return resolve7(p);
 }
 function normalizeTargetPath(p) {
   const expanded = expandPath(p);
@@ -11942,7 +12053,7 @@ function normalizeTargetPath(p) {
     while (true) {
       if (existsSync6(current)) {
         try {
-          return resolve5(realpathSync2(current), ...missingSegments);
+          return resolve7(realpathSync2(current), ...missingSegments);
         } catch {
           return expanded;
         }
@@ -11971,7 +12082,7 @@ async function writeConfigResult(config, targetPath, content, opts, meta = {}) {
   }
   const path = expandPath(renderedTargetPath);
   const renderedForTarget = isCursorGlobalAuthorityPath(path) ? stampCursorGlobalAuthorityMarker(renderedContent) : renderedContent;
-  const previousContent = existsSync6(path) ? readFileSync5(path, "utf-8") : null;
+  const previousContent = existsSync6(path) ? readFileSync6(path, "utf-8") : null;
   const changed = previousContent !== renderedForTarget;
   if (!opts.dryRun) {
     const dir = dirname4(path);
@@ -12011,7 +12122,7 @@ function wouldDestroyACredential(targetPath, renderedContent, format) {
     const path = expandPath(targetPath);
     if (!existsSync6(path))
       return [];
-    current = readFileSync5(path, "utf-8");
+    current = readFileSync6(path, "utf-8");
   } catch {
     return secretTokens;
   }
@@ -12335,14 +12446,14 @@ 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(join7(home, ...relativePath.split("/"))))))
+  if ([...homes].some((home) => SESSION_RENDER_OWNED_CONFIG_TARGETS.some((relativePath) => normalized === normalizeTargetPath(join9(home, ...relativePath.split("/"))))))
     return true;
   return sessionRenderOwnsPath(normalized);
 }
 
 // src/lib/package-version.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname5, join as join10 } from "path";
 import { fileURLToPath } from "url";
 var cached = null;
 function getPackageVersion() {
@@ -12351,9 +12462,9 @@ function getPackageVersion() {
   try {
     let dir = dirname5(fileURLToPath(import.meta.url));
     for (let i = 0;i < 8; i++) {
-      const pkgPath = join8(dir, "package.json");
+      const pkgPath = join10(dir, "package.json");
       if (existsSync7(pkgPath)) {
-        const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
         if (pkg.name === "@hasna/instructions" && pkg.version) {
           cached = pkg.version;
           return cached;
@@ -12369,6 +12480,403 @@ function getPackageVersion() {
   return cached;
 }
 
+// src/lib/managed-skill-runtimes.ts
+import { createHash as createHash8 } from "crypto";
+import { spawnSync } from "child_process";
+import {
+  existsSync as existsSync8,
+  lstatSync as lstatSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync8,
+  renameSync as renameSync2,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname6, join as join11, parse as parse4, relative as relative4, resolve as resolve8 } from "path";
+var INBOX_CONVERSATIONS_MINIMUM_VERSION = "0.5.28";
+var INBOX_SKILL_MARKERS = [
+  [".claude", "skills", "inbox", "SKILL.md"],
+  [".codex", "skills", "inbox", "SKILL.md"],
+  [".codewith", "skills", "inbox", "SKILL.md"],
+  [".config", "opencode", "skills", "inbox", "SKILL.md"],
+  [".cursor", "skills", "inbox", "SKILL.md"]
+];
+var REQUIRED_WATCH_FLAGS = ["--from <agent>", "--all", "--full-content"];
+function sha2568(content) {
+  return createHash8("sha256").update(content).digest("hex");
+}
+function lstatOrNull(path) {
+  try {
+    return lstatSync4(path);
+  } catch {
+    return null;
+  }
+}
+function findSymlinkedAncestor(path) {
+  const normalized = resolve8(path);
+  const parsed = parse4(normalized);
+  let current = parsed.root;
+  const rel = relative4(parsed.root, normalized);
+  for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
+    current = join11(current, segment);
+    if (!existsSync8(current))
+      return null;
+    if (lstatSync4(current).isSymbolicLink())
+      return current;
+  }
+  return null;
+}
+function assertNoSymlinkAncestors2(path) {
+  const found = findSymlinkedAncestor(path);
+  if (found !== null) {
+    throw new Error(`managed skill path uses a symlink ancestor: ${found}`);
+  }
+}
+function packagedInboxSkillPath(explicitPath) {
+  if (explicitPath)
+    return explicitPath;
+  const candidates = [
+    join11(import.meta.dir, "..", "..", "assets", "skills", "inbox", "SKILL.md"),
+    join11(import.meta.dir, "..", "assets", "skills", "inbox", "SKILL.md"),
+    join11(process.cwd(), "assets", "skills", "inbox", "SKILL.md")
+  ];
+  const found = candidates.find((candidate) => existsSync8(candidate));
+  if (!found) {
+    throw new Error(`packaged inbox skill contract is missing (checked ${candidates.length} package-relative locations)`);
+  }
+  return found;
+}
+function readCanonicalSkill(explicitPath) {
+  const assetPath = packagedInboxSkillPath(explicitPath);
+  const stat = lstatOrNull(assetPath);
+  if (!stat?.isFile()) {
+    throw new Error("packaged inbox skill contract is not a regular file");
+  }
+  const content = readFileSync8(assetPath, "utf8");
+  if (!content.includes("conversations watch --from <agent> --all")) {
+    throw new Error("packaged inbox skill contract does not declare the canonical conversations watcher");
+  }
+  if (!content.includes("There is no separate")) {
+    throw new Error("packaged inbox skill contract does not retire the legacy executable");
+  }
+  return { content, sha256: sha2568(content) };
+}
+function runProbe(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    timeout: 5000,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error || result.status !== 0) {
+    return { ok: false, output: "" };
+  }
+  return {
+    ok: true,
+    output: `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim()
+  };
+}
+function parseVersion(output) {
+  return output.match(/\b(\d+\.\d+\.\d+)\b/)?.[1] ?? null;
+}
+function compareVersions(left, right) {
+  const a = left.split(".").map(Number);
+  const b = right.split(".").map(Number);
+  for (let i = 0;i < Math.max(a.length, b.length); i++) {
+    const delta = (a[i] ?? 0) - (b[i] ?? 0);
+    if (delta !== 0)
+      return delta;
+  }
+  return 0;
+}
+function inspectSkillMarkers(homeDir2) {
+  return INBOX_SKILL_MARKERS.map((parts) => join11(homeDir2, ...parts)).map((path) => {
+    const stat = lstatOrNull(path);
+    if (!stat)
+      return null;
+    if (!stat.isFile()) {
+      return { path, content: null, mode: null, regular: false };
+    }
+    return {
+      path,
+      content: readFileSync8(path, "utf8"),
+      mode: stat.mode & 511,
+      regular: true
+    };
+  }).filter((snapshot) => snapshot !== null);
+}
+function inspectInbox(options) {
+  const homeDir2 = options.homeDir ?? homedir6();
+  const runtimeCommand = options.conversationsCommand ?? "conversations";
+  const snapshots = inspectSkillMarkers(homeDir2);
+  const skillPresent = snapshots.length > 0;
+  let canonicalContent = null;
+  let canonicalSha256 = null;
+  let assetError = null;
+  try {
+    const canonical = readCanonicalSkill(options.assetPath);
+    canonicalContent = canonical.content;
+    canonicalSha256 = canonical.sha256;
+  } catch (error) {
+    assetError = error instanceof Error ? error.message : String(error);
+  }
+  const versionProbe = skillPresent ? runProbe(runtimeCommand, ["--version"]) : { ok: false, output: "" };
+  const helpProbe = versionProbe.ok ? runProbe(runtimeCommand, ["watch", "--help"]) : { ok: false, output: "" };
+  const runtimeVersion = versionProbe.ok ? parseVersion(versionProbe.output) : null;
+  const supportsFrom = helpProbe.ok && helpProbe.output.includes(REQUIRED_WATCH_FLAGS[0]);
+  const supportsAll = helpProbe.ok && helpProbe.output.includes(REQUIRED_WATCH_FLAGS[1]);
+  const supportsFullContent = helpProbe.ok && helpProbe.output.includes(REQUIRED_WATCH_FLAGS[2]);
+  const packageReady = versionProbe.ok && runtimeVersion !== null && compareVersions(runtimeVersion, INBOX_CONVERSATIONS_MINIMUM_VERSION) >= 0 && helpProbe.ok && supportsFrom && supportsAll && supportsFullContent;
+  const heartbeatProbe = skillPresent && packageReady && options.agent ? runProbe(runtimeCommand, ["agents", "heartbeat", "--from", options.agent, "--json"]) : null;
+  const hostedHeartbeat = heartbeatProbe === null ? "unverified" : heartbeatProbe.ok ? "passed" : "failed";
+  const deliveryVerified = hostedHeartbeat === "passed" && options.deliveryVerified === true;
+  const staleMarkers = canonicalContent === null ? snapshots.map((snapshot) => snapshot.path) : snapshots.filter((snapshot) => !snapshot.regular || snapshot.content !== canonicalContent).map((snapshot) => snapshot.path);
+  let reason = "skill not installed";
+  if (skillPresent) {
+    const nonRegular = snapshots.some((snapshot) => !snapshot.regular);
+    const symlinkAncestor = snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname6(path))).find((found) => found !== null);
+    if (nonRegular)
+      reason = "managed skill target is not a regular file";
+    else if (symlinkAncestor)
+      reason = `managed skill path uses a symlink ancestor: ${symlinkAncestor}`;
+    else if (assetError)
+      reason = assetError;
+    else if (!versionProbe.ok)
+      reason = "conversations command unavailable";
+    else if (!runtimeVersion)
+      reason = "conversations version is unreadable";
+    else if (compareVersions(runtimeVersion, INBOX_CONVERSATIONS_MINIMUM_VERSION) < 0) {
+      reason = `conversations ${runtimeVersion} is older than ${INBOX_CONVERSATIONS_MINIMUM_VERSION}`;
+    } else if (!helpProbe.ok)
+      reason = "conversations watch help is unavailable";
+    else if (!supportsFrom || !supportsAll || !supportsFullContent) {
+      const missing = [
+        !supportsFrom ? "--from" : null,
+        !supportsAll ? "--all" : null,
+        !supportsFullContent ? "--full-content" : null
+      ].filter((flag) => flag !== null);
+      reason = `conversations watch is missing required flags: ${missing.join(", ")}`;
+    } else if (staleMarkers.length > 0)
+      reason = "skill contract stale";
+    else if (hostedHeartbeat === "failed")
+      reason = "hosted heartbeat failed; manual fallback required";
+    else if (hostedHeartbeat === "unverified")
+      reason = "hosted heartbeat unverified; manual fallback required";
+    else if (!deliveryVerified)
+      reason = "hosted heartbeat passed; channel and DM delivery verification required";
+    else
+      reason = "ready";
+  }
+  return {
+    status: {
+      skill: "inbox",
+      runtime: "conversations watch",
+      minimum_version: INBOX_CONVERSATIONS_MINIMUM_VERSION,
+      skill_present: skillPresent,
+      skill_markers: snapshots.map((snapshot) => snapshot.path),
+      skill_contracts_current: snapshots.length - staleMarkers.length,
+      stale_skill_markers: staleMarkers,
+      expected_skill_sha256: canonicalSha256,
+      runtime_command: runtimeCommand,
+      runtime_present: versionProbe.ok,
+      runtime_version: runtimeVersion,
+      watch_supports_from: supportsFrom,
+      watch_supports_all: supportsAll,
+      watch_supports_full_content: supportsFullContent,
+      hosted_heartbeat: hostedHeartbeat,
+      delivery_verified: deliveryVerified,
+      manual_fallback_ready: skillPresent && staleMarkers.length === 0 && packageReady,
+      healthy: !skillPresent || reason === "ready",
+      reason
+    },
+    canonicalContent,
+    snapshots
+  };
+}
+function inspectManagedSkillRuntimes(options = {}) {
+  const runtime = inspectInbox(options).status;
+  const installed = runtime.skill_present ? [runtime] : [];
+  return {
+    runtimes: [runtime],
+    skills_present: installed.length,
+    healthy: installed.filter((item) => item.healthy).length,
+    missing: installed.filter((item) => !item.healthy).length
+  };
+}
+function runtimeReadyForWrite(status) {
+  return status.runtime_present && status.runtime_version !== null && compareVersions(status.runtime_version, INBOX_CONVERSATIONS_MINIMUM_VERSION) >= 0 && status.watch_supports_from && status.watch_supports_all && status.watch_supports_full_content;
+}
+function projectUpdatedStatus(status, contractCount) {
+  const healthy = status.hosted_heartbeat === "passed" && status.delivery_verified;
+  return {
+    ...status,
+    skill_contracts_current: contractCount,
+    stale_skill_markers: [],
+    manual_fallback_ready: true,
+    healthy,
+    reason: healthy ? "ready" : status.hosted_heartbeat === "failed" ? "hosted heartbeat failed; manual fallback required" : status.hosted_heartbeat === "unverified" ? "hosted heartbeat unverified; manual fallback required" : "hosted heartbeat passed; channel and DM delivery verification required"
+  };
+}
+function cleanup(path) {
+  rmSync3(path, { force: true });
+}
+function writeAtomic(path, content, mode) {
+  assertNoSymlinkAncestors2(dirname6(path));
+  const tempPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  try {
+    mkdirSync4(dirname6(path), { recursive: true, mode: 493 });
+    writeFileSync3(tempPath, content, { mode, flag: "wx" });
+    renameSync2(tempPath, path);
+  } finally {
+    cleanup(tempPath);
+  }
+}
+var DEFAULT_SKILL_WRITE_FILE_OPERATIONS = {
+  lstat: lstatOrNull,
+  read: (path) => readFileSync8(path, "utf8"),
+  write: writeAtomic
+};
+function writeSkillContractsTransactional(snapshots, canonicalContent, fileOperations = DEFAULT_SKILL_WRITE_FILE_OPERATIONS) {
+  const written = [];
+  try {
+    for (const snapshot of snapshots) {
+      const currentStat = fileOperations.lstat(snapshot.path);
+      if (!currentStat?.isFile() || fileOperations.read(snapshot.path) !== snapshot.content) {
+        throw new Error("managed skill changed after inspection; refusing a stale write");
+      }
+      fileOperations.write(snapshot.path, canonicalContent, snapshot.mode);
+      written.push(snapshot);
+    }
+    return { ok: true, error: null, rollback_conflicts: [] };
+  } catch (error) {
+    const rollbackConflicts = [];
+    for (const snapshot of written.reverse()) {
+      const currentStat = fileOperations.lstat(snapshot.path);
+      if (!currentStat?.isFile()) {
+        rollbackConflicts.push(`${snapshot.path}: no longer a regular file`);
+        continue;
+      }
+      let currentContent;
+      try {
+        currentContent = fileOperations.read(snapshot.path);
+      } catch {
+        rollbackConflicts.push(`${snapshot.path}: could not read the current file`);
+        continue;
+      }
+      if (currentContent !== canonicalContent) {
+        rollbackConflicts.push(`${snapshot.path}: changed after this reconciliation wrote it`);
+        continue;
+      }
+      try {
+        fileOperations.write(snapshot.path, snapshot.content, snapshot.mode);
+      } catch {
+        rollbackConflicts.push(`${snapshot.path}: still owned but could not be restored`);
+      }
+    }
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      rollback_conflicts: rollbackConflicts
+    };
+  }
+}
+async function reconcileManagedSkillRuntimes(options = {}) {
+  const dryRun = options.dryRun ?? false;
+  const before = inspectInbox(options);
+  const status = before.status;
+  if (!status.skill_present) {
+    return {
+      runtimes: [{ ...status, action: "skipped", dry_run: dryRun, skill_contracts_changed: 0 }],
+      changed: 0,
+      failed: 0,
+      dry_run: dryRun
+    };
+  }
+  if (before.snapshots.some((snapshot) => !snapshot.regular)) {
+    return {
+      runtimes: [{ ...status, action: "failed", dry_run: dryRun, skill_contracts_changed: 0 }],
+      changed: 0,
+      failed: 1,
+      dry_run: dryRun
+    };
+  }
+  const symlinkedAncestor = before.snapshots.map((snapshot) => snapshot.path).map((path) => findSymlinkedAncestor(dirname6(path))).find((found) => found !== null);
+  if (symlinkedAncestor) {
+    return {
+      runtimes: [{ ...status, action: "failed", dry_run: dryRun, skill_contracts_changed: 0 }],
+      changed: 0,
+      failed: 1,
+      dry_run: dryRun
+    };
+  }
+  if (!before.canonicalContent || !runtimeReadyForWrite(status)) {
+    return {
+      runtimes: [{ ...status, action: "failed", dry_run: dryRun, skill_contracts_changed: 0 }],
+      changed: 0,
+      failed: 1,
+      dry_run: dryRun
+    };
+  }
+  const staleSnapshots = before.snapshots.filter((snapshot) => snapshot.content !== before.canonicalContent);
+  if (staleSnapshots.length === 0) {
+    return {
+      runtimes: [{ ...status, action: "unchanged", dry_run: dryRun, skill_contracts_changed: 0 }],
+      changed: 0,
+      failed: 0,
+      dry_run: dryRun
+    };
+  }
+  if (dryRun) {
+    const projected = projectUpdatedStatus(status, before.snapshots.length);
+    return {
+      runtimes: [{
+        ...projected,
+        action: "update",
+        dry_run: true,
+        skill_contracts_changed: staleSnapshots.length
+      }],
+      changed: 1,
+      failed: 0,
+      dry_run: true
+    };
+  }
+  const transaction = writeSkillContractsTransactional(staleSnapshots.map((snapshot) => ({
+    path: snapshot.path,
+    content: snapshot.content,
+    mode: snapshot.mode ?? 420
+  })), before.canonicalContent);
+  if (!transaction.ok) {
+    const rollbackConflictReason = transaction.rollback_conflicts.length > 0 ? `; rollback conflicts: ${transaction.rollback_conflicts.join("; ")}` : "";
+    const reason = `${transaction.error ?? "managed skill reconciliation failed"}${rollbackConflictReason}`;
+    return {
+      runtimes: [{
+        ...status,
+        action: "failed",
+        dry_run: false,
+        skill_contracts_changed: 0,
+        reason
+      }],
+      changed: 0,
+      failed: 1,
+      dry_run: false
+    };
+  }
+  const after = inspectInbox(options).status;
+  const accepted = after.healthy || after.manual_fallback_ready;
+  return {
+    runtimes: [{
+      ...after,
+      action: accepted ? "update" : "failed",
+      dry_run: false,
+      skill_contracts_changed: accepted ? staleSnapshots.length : 0
+    }],
+    changed: accepted ? 1 : 0,
+    failed: accepted ? 0 : 1,
+    dry_run: false
+  };
+}
+
 // src/status.ts
 var PACKAGE_NAME = "@hasna/instructions";
 var PACKAGE_VERSION = getPackageVersion();
@@ -12391,7 +12899,7 @@ function countBy(items, getValue) {
   }
   return counts;
 }
-async function getConfigsStatus(store = resolveConfigStore()) {
+async function getConfigsStatus(store = resolveConfigStore(), options = {}) {
   let databaseReachable = true;
   let configs = [];
   let categoryStats = { total: 0 };
@@ -12415,11 +12923,11 @@ async function getConfigsStatus(store = resolveConfigStore()) {
       continue;
     knownTargets += 1;
     const targetPath = expandPath(config.target_path);
-    if (!existsSync8(targetPath)) {
+    if (!existsSync9(targetPath)) {
       missingTargets += 1;
       continue;
     }
-    const disk = readFileSync7(targetPath, "utf-8");
+    const disk = readFileSync9(targetPath, "utf-8");
     const { content: redactedDisk } = redactContent(disk, config.format);
     if (redactedDisk !== config.content) {
       driftedTargets += 1;
@@ -12445,7 +12953,11 @@ async function getConfigsStatus(store = resolveConfigStore()) {
     }
   }
   const byCategory = Object.fromEntries(Object.entries(categoryStats).filter(([key]) => key !== "total"));
-  const status = databaseReachable && driftedTargets === 0 && missingTargets === 0 && unredactedSecretFindings === 0 && retiredAgentRows === 0 ? "ok" : "warn";
+  const managedSkillRuntimes = inspectManagedSkillRuntimes({
+    homeDir: options.homeDir,
+    conversationsCommand: options.conversationsCommand
+  });
+  const status = databaseReachable && driftedTargets === 0 && missingTargets === 0 && unredactedSecretFindings === 0 && retiredAgentRows === 0 && managedSkillRuntimes.missing === 0 ? "ok" : "warn";
   return {
     service: "configs",
     schemaVersion: "1.0",
@@ -12475,7 +12987,12 @@ async function getConfigsStatus(store = resolveConfigStore()) {
       profileLinks,
       machines,
       snapshots,
-      knownTargets
+      knownTargets,
+      managedSkillRuntimes: {
+        skillsPresent: managedSkillRuntimes.skills_present,
+        healthy: managedSkillRuntimes.healthy,
+        missing: managedSkillRuntimes.missing
+      }
     },
     health: {
       status,
@@ -12484,10 +13001,12 @@ async function getConfigsStatus(store = resolveConfigStore()) {
       missingTargets,
       unredactedSecretFindings,
       retiredAgentRows,
+      missingManagedSkillRuntimes: managedSkillRuntimes.missing,
       hasDrift: driftedTargets > 0,
       hasMissingTargets: missingTargets > 0,
       hasUnredactedSecrets: unredactedSecretFindings > 0,
-      hasRetiredAgentRows: retiredAgentRows > 0
+      hasRetiredAgentRows: retiredAgentRows > 0,
+      hasMissingManagedSkillRuntimes: managedSkillRuntimes.missing > 0
     },
     safety: {
       includesConfigValues: false,
@@ -12572,16 +13091,16 @@ var PG_MIGRATIONS = [
   `CREATE INDEX IF NOT EXISTS profile_assets_source_config_idx ON profile_assets (source_config_id)`
 ];
 // src/lib/session-apply.ts
-import { createHash as createHash7, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash9, randomUUID as randomUUID4 } from "crypto";
 import {
-  existsSync as existsSync9,
-  lstatSync as lstatSync3,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync8,
+  existsSync as existsSync10,
+  lstatSync as lstatSync5,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync10,
   readdirSync,
-  statSync as statSync4
+  statSync as statSync5
 } from "fs";
-import { dirname as dirname6, isAbsolute as isAbsolute4, join as join9, parse as parse4, relative as relative4, resolve as resolve6 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join12, parse as parse5, relative as relative5, resolve as resolve9 } from "path";
 class SessionApplyError extends Error {
   constructor(message) {
     super(message);
@@ -12601,6 +13120,7 @@ function applySessionRenderUnlocked(plan, options, coordination) {
   }
   assertCursorAuthorityUnchanged(plan);
   const targetHome = assertSafeTargetHome(plan.targetHome);
+  assertClaudeAuthorityStillClear(plan, targetHome);
   const payloadFiles = [...plan.files, ...plan.assetFiles ?? []];
   const files = [...payloadFiles, plan.manifestFile];
   const manifestPath = resolvePlannedFilePath(plan, plan.manifestFile, targetHome);
@@ -12701,14 +13221,23 @@ function assertCursorAuthorityUnchanged(plan) {
     throw new SessionApplyError("Cursor fixed global authority changed after planning; refusing to apply a stale render plan.");
   }
 }
+function assertClaudeAuthorityStillClear(plan, targetHome) {
+  if (plan.tool !== "claude" || plan.targetKind === "blocked")
+    return;
+  const conflicts = detectClaudeAuthorityConflicts(targetHome);
+  if (conflicts.length === 0)
+    return;
+  const summary = conflicts.map((conflict) => `${conflict.relativePath}: ${conflict.reason}`).join("; ");
+  throw new SessionApplyError(`Claude authority changed after planning; refusing to apply: ${summary}`);
+}
 function ensureSessionTargetHome(targetHome) {
-  if (!existsSync9(targetHome))
-    mkdirSync4(targetHome, { recursive: true, mode: 448 });
+  if (!existsSync10(targetHome))
+    mkdirSync5(targetHome, { recursive: true, mode: 448 });
   assertSafeTargetHome(targetHome);
 }
 function checkSessionRenderDrift(targetHome, manifestPath) {
   const safeTargetHome = assertSafeTargetHome(targetHome);
-  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative4(safeTargetHome, resolve6(manifestPath)), safeTargetHome) : resolve6(safeTargetHome, ".hasna", "session-render-manifest.json");
+  const resolvedManifestPath = manifestPath ? resolveManifestRelativePath(relative5(safeTargetHome, resolve9(manifestPath)), safeTargetHome) : resolve9(safeTargetHome, ".hasna", "session-render-manifest.json");
   const checkedAt = new Date().toISOString();
   const previousManifest = readPreviousManifest(resolvedManifestPath);
   if (!previousManifest) {
@@ -12725,7 +13254,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
   const drifted = [];
   for (const file of previousManifest.files) {
     const target = resolveManifestRelativePath(file.relativePath, safeTargetHome);
-    if (!existsSync9(target)) {
+    if (!existsSync10(target)) {
       missing.push({
         path: target,
         relativePath: file.relativePath,
@@ -12735,7 +13264,7 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
       });
       continue;
     }
-    const actualSha256 = sha2567(readFileSync8(target, "utf-8"));
+    const actualSha256 = sha2569(readFileSync10(target, "utf-8"));
     if (actualSha256 !== file.sha256) {
       drifted.push({
         path: target,
@@ -12758,8 +13287,8 @@ function checkSessionRenderDrift(targetHome, manifestPath) {
 function restoreSessionRenderSnapshot(snapshotPath, options = {}) {
   const snapshot = readSessionRenderSnapshot(snapshotPath);
   const targetHome = assertSafeTargetHome(snapshot.targetHome);
-  const resolvedSnapshotPath = resolve6(snapshotPath);
-  const snapshotRelativePath = relative4(targetHome, resolvedSnapshotPath);
+  const resolvedSnapshotPath = resolve9(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.");
   }
@@ -12876,19 +13405,19 @@ function requiredRestoreHash(file) {
   return file.previousSha256;
 }
 function readSessionRenderSnapshot(snapshotPath) {
-  const resolved = resolve6(snapshotPath);
-  if (!existsSync9(resolved))
+  const resolved = resolve9(snapshotPath);
+  if (!existsSync10(resolved))
     throw new SessionApplyError(`Session snapshot not found: ${snapshotPath}`);
-  const stat = lstatSync3(resolved);
+  const stat = lstatSync5(resolved);
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw new SessionApplyError(`Session snapshot is not a regular file: ${snapshotPath}`);
   }
-  if (statSync4(resolved).size > 32 * 1024 * 1024) {
+  if (statSync5(resolved).size > 32 * 1024 * 1024) {
     throw new SessionApplyError(`Session snapshot exceeds the 32 MiB restore limit: ${snapshotPath}`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync8(resolved, "utf8"));
+    parsed = JSON.parse(readFileSync10(resolved, "utf8"));
   } catch {
     throw new SessionApplyError(`Session snapshot is not valid JSON: ${snapshotPath}`);
   }
@@ -12910,7 +13439,7 @@ function readSessionRenderSnapshot(snapshotPath) {
   const previousManifest = snapshot.previousManifest;
   const previousFiles = new Map;
   for (const file of snapshot.files) {
-    if (!file || typeof file.relativePath !== "string" || typeof file.path !== "string" || typeof file.sha256 !== "string" || typeof file.content !== "string" || sha2567(file.content) !== file.sha256) {
+    if (!file || typeof file.relativePath !== "string" || typeof file.path !== "string" || typeof file.sha256 !== "string" || typeof file.content !== "string" || sha2569(file.content) !== file.sha256) {
       throw new SessionApplyError(`Session snapshot previous file metadata is invalid: ${snapshotPath}`);
     }
     resolveSnapshotFilePath(file.relativePath, file.path, targetHome);
@@ -12957,8 +13486,8 @@ function readSessionRenderSnapshot(snapshotPath) {
 }
 function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previousManifestFiles, targetHome, snapshotPath) {
   assertNoNewerSessionSnapshot(snapshotPath, snapshot.createdAt, targetHome);
-  const manifestPath = resolve6(snapshot.manifestPath);
-  const manifestRelativePath = relative4(targetHome, manifestPath).replaceAll("\\", "/");
+  const manifestPath = resolve9(snapshot.manifestPath);
+  const manifestRelativePath = relative5(targetHome, manifestPath).replaceAll("\\", "/");
   resolveSnapshotFilePath(manifestRelativePath, snapshot.manifestPath, targetHome);
   const manifestSha256 = currentSessionFileHash(manifestPath, targetHome);
   if (manifestSha256 === null) {
@@ -12966,7 +13495,7 @@ function reconstructPreRollbackLegacyV1Snapshot(snapshot, previousFiles, previou
   }
   let parsedManifest;
   try {
-    parsedManifest = JSON.parse(readFileSync8(manifestPath, "utf8"));
+    parsedManifest = JSON.parse(readFileSync10(manifestPath, "utf8"));
   } catch {
     throw new SessionApplyError(`Pre-rollback legacy v1 applied manifest is not valid JSON: ${snapshotPath}`);
   }
@@ -12974,7 +13503,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" || resolve6(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" || resolve9(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 = [];
@@ -13058,17 +13587,17 @@ function assertNoNewerSessionSnapshot(snapshotPath, createdAt, targetHome) {
   if (!Number.isFinite(createdAtMs)) {
     throw new SessionApplyError(`Pre-rollback legacy v1 snapshot has an invalid creation time: ${snapshotPath}`);
   }
-  for (const entry of readdirSync(dirname6(snapshotPath))) {
-    const candidatePath = resolve6(dirname6(snapshotPath), entry);
-    if (candidatePath === resolve6(snapshotPath) || !entry.endsWith(".json"))
+  for (const entry of readdirSync(dirname7(snapshotPath))) {
+    const candidatePath = resolve9(dirname7(snapshotPath), entry);
+    if (candidatePath === resolve9(snapshotPath) || !entry.endsWith(".json"))
       continue;
-    const candidateStat = lstatSync3(candidatePath);
+    const candidateStat = lstatSync5(candidatePath);
     if (candidateStat.isSymbolicLink() || !candidateStat.isFile() || candidateStat.size > 32 * 1024 * 1024)
       continue;
     try {
-      const candidate = JSON.parse(readFileSync8(candidatePath, "utf8"));
+      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" && resolve6(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" && resolve9(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) {
@@ -13126,7 +13655,7 @@ function inferLegacySnapshotAction(file, previousFiles, previousManifestFiles, p
     return "create";
   }
   if (file.role === "manifest" && previousManifest) {
-    const previousManifestSha256 = sha2567(`${JSON.stringify(previousManifest, null, 2)}
+    const previousManifestSha256 = sha2569(`${JSON.stringify(previousManifest, null, 2)}
 `);
     if (previousManifestSha256 !== file.sha256) {
       throw new SessionApplyError(`Cannot infer legacy v1 manifest action without a before-image: ${file.relativePath}`);
@@ -13137,15 +13666,15 @@ function inferLegacySnapshotAction(file, previousFiles, previousManifestFiles, p
 }
 function resolveSnapshotFilePath(relativePath, recordedPath, targetHome) {
   const path = resolveManifestRelativePath(relativePath, targetHome);
-  if (resolve6(recordedPath) !== path) {
+  if (resolve9(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 = existsSync9(target) ? readFileSync8(target, "utf-8") : null;
-  const previousSha256 = previousContent === null ? null : sha2567(previousContent);
+  const previousContent = existsSync10(target) ? readFileSync10(target, "utf-8") : null;
+  const previousSha256 = previousContent === null ? null : sha2569(previousContent);
   const previouslyManaged = isPreviouslyManaged(file, previousSha256, previousHashes, previousManifest);
   const changed = previousContent !== file.content;
   if (previousContent !== null && !options.force && !previouslyManaged) {
@@ -13240,10 +13769,10 @@ function planStaleFileResults(plan, targetHome, previousManifest, currentRelativ
 }
 function planStaleFileResult(file, targetHome, options) {
   const target = resolveManifestRelativePath(file.relativePath, targetHome);
-  if (!existsSync9(target))
+  if (!existsSync10(target))
     return null;
-  const previousContent = readFileSync8(target, "utf-8");
-  const previousSha256 = sha2567(previousContent);
+  const previousContent = readFileSync10(target, "utf-8");
+  const previousSha256 = sha2569(previousContent);
   if (!options.force && previousSha256 !== file.sha256) {
     return {
       path: target,
@@ -13287,20 +13816,20 @@ function isPreviouslyManaged(file, previousSha256, previousHashes, previousManif
   return previousHashes.get(file.relativePath) === previousSha256;
 }
 function resolvePlannedFilePath(plan, file, targetHome) {
-  const target = resolve6(targetHome, ...file.relativePath.split("/"));
-  const rel = relative4(targetHome, target);
+  const target = resolve9(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 (resolve6(file.path) !== target) {
+  if (resolve9(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 = resolve6(targetHome, ...relativePath.split(/[\\/]+/));
-  const rel = relative4(targetHome, target);
+  const target = resolve9(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}`);
   }
@@ -13308,10 +13837,10 @@ function resolveManifestRelativePath(relativePath, targetHome) {
   return target;
 }
 function readPreviousManifest(path) {
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync10(path, "utf-8"));
     if (parsed.schema !== SESSION_RENDER_SCHEMA)
       return null;
     if (!Array.isArray(parsed.files))
@@ -13345,18 +13874,18 @@ function applyPlannedFile(plan, file, targetHome, resultsByPath, coordination, a
 function assertExpectedSessionFileHash(path, targetHome, expectedHash) {
   const actualHash = currentSessionFileHash(path, targetHome);
   if (actualHash !== expectedHash) {
-    throw new SessionApplyError(`Session apply path changed after planning: ${relative4(targetHome, path)}`);
+    throw new SessionApplyError(`Session apply path changed after planning: ${relative5(targetHome, path)}`);
   }
 }
 function currentSessionFileHash(path, targetHome) {
   assertNoSymlinkSegments2(targetHome, path);
-  if (!existsSync9(path))
+  if (!existsSync10(path))
     return null;
-  const stat = lstatSync3(path);
+  const stat = lstatSync5(path);
   if (stat.isSymbolicLink() || !stat.isFile()) {
     throw new SessionApplyError(`Session apply path is not a regular file: ${path}`);
   }
-  return sha2567(readFileSync8(path, "utf-8"));
+  return sha2569(readFileSync10(path, "utf-8"));
 }
 function requiredPreviousHash(result) {
   if (result.previousSha256 === null) {
@@ -13365,13 +13894,13 @@ function requiredPreviousHash(result) {
   return result.previousSha256;
 }
 function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousManifest, coordination, allowPortableFallback, forcePortableFileOps) {
-  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").filter((result) => existsSync9(result.path)).map((result) => {
-    const content = readFileSync8(result.path, "utf-8");
+  const existingFiles = results.filter((result) => result.action === "update" || result.action === "delete").filter((result) => existsSync10(result.path)).map((result) => {
+    const content = readFileSync10(result.path, "utf-8");
     return {
       path: result.path,
       relativePath: result.relativePath,
       role: result.role,
-      sha256: sha2567(content),
+      sha256: sha2569(content),
       content
     };
   });
@@ -13384,7 +13913,7 @@ function writeSessionSnapshot(plan, targetHome, manifestPath, results, previousM
     };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const snapshotPath = resolve6(targetHome, ".hasna", "session-render-snapshots", `${timestamp}-${randomUUID4()}.json`);
+  const snapshotPath = resolve9(targetHome, ".hasna", "session-render-snapshots", `${timestamp}-${randomUUID4()}.json`);
   const afterFiles = results.map((result) => {
     if (result.action === "conflict") {
       throw new SessionApplyError(`Cannot snapshot unresolved conflict: ${result.relativePath}`);
@@ -13432,43 +13961,43 @@ 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 = resolve6(targetHome);
-  if (normalized === parse4(normalized).root) {
+  const normalized = resolve9(targetHome);
+  if (normalized === parse5(normalized).root) {
     throw new SessionApplyError(`Session target home cannot be the filesystem root: ${targetHome}`);
   }
-  assertNoSymlinkAncestors2(normalized);
-  if (existsSync9(normalized) && lstatSync3(normalized).isSymbolicLink()) {
+  assertNoSymlinkAncestors3(normalized);
+  if (existsSync10(normalized) && lstatSync5(normalized).isSymbolicLink()) {
     throw new SessionApplyError(`Session target home cannot be a symlink: ${normalized}`);
   }
   return normalized;
 }
 function assertNoSymlinkSegments2(root, target) {
-  assertNoSymlinkAncestors2(root);
-  const rel = relative4(root, target);
+  assertNoSymlinkAncestors3(root);
+  const rel = relative5(root, target);
   let current = root;
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join9(current, segment);
-    if (existsSync9(current) && lstatSync3(current).isSymbolicLink()) {
+    current = join12(current, segment);
+    if (existsSync10(current) && lstatSync5(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink: ${current}`);
     }
   }
 }
-function assertNoSymlinkAncestors2(path) {
-  const normalized = resolve6(path);
-  const parsed = parse4(normalized);
+function assertNoSymlinkAncestors3(path) {
+  const normalized = resolve9(path);
+  const parsed = parse5(normalized);
   let current = parsed.root;
-  const rel = relative4(parsed.root, normalized);
+  const rel = relative5(parsed.root, normalized);
   for (const segment of rel.split(/[\\/]+/).filter(Boolean)) {
-    current = join9(current, segment);
-    if (!existsSync9(current))
+    current = join12(current, segment);
+    if (!existsSync10(current))
       return;
-    if (lstatSync3(current).isSymbolicLink()) {
+    if (lstatSync5(current).isSymbolicLink()) {
       throw new SessionApplyError(`Session apply path uses a symlink ancestor: ${current}`);
     }
   }
 }
-function sha2567(content) {
-  return createHash7("sha256").update(content).digest("hex");
+function sha2569(content) {
+  return createHash9("sha256").update(content).digest("hex");
 }
 // src/lib/project-dashboard-standard.ts
 var PROJECT_DASHBOARD_STANDARD_SLUG = "agent-managed-project-dashboard-standard";
@@ -13771,13 +14300,13 @@ async function ensureDangerousOperationGuardStandardConfig(store = resolveConfig
   }
 }
 // src/lib/sync.ts
-import { existsSync as existsSync11, readdirSync as readdirSync3, readFileSync as readFileSync10 } from "fs";
-import { basename as basename5, extname as extname3, join as join11 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync3, readFileSync as readFileSync12 } from "fs";
+import { basename as basename5, extname as extname3, join as join14 } from "path";
 
 // src/lib/sync-dir.ts
-import { existsSync as existsSync10, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
-import { join as join10, relative as relative5 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync11, readdirSync as readdirSync2, readFileSync as readFileSync11, statSync as statSync6 } from "fs";
+import { join as join13, relative as relative6 } from "path";
+import { homedir as homedir7 } from "os";
 var SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
 function shouldSkip(p) {
   return SKIP.some((s) => p.includes(s));
@@ -13785,11 +14314,11 @@ function shouldSkip(p) {
 async function syncFromDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
   const absDir = expandPath(dir);
-  if (!existsSync10(absDir))
+  if (!existsSync11(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join10(absDir, f)).filter((f) => statSync5(f).isFile());
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync2(absDir).map((f) => join13(absDir, f)).filter((f) => statSync6(f).isFile());
   const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
-  const home = homedir5();
+  const home = homedir7();
   const allConfigs = await store.listConfigs();
   for (const file of files) {
     if (shouldSkip(file)) {
@@ -13797,7 +14326,7 @@ async function syncFromDir(dir, opts = {}) {
       continue;
     }
     try {
-      const content = readFileSync9(file, "utf-8");
+      const content = readFileSync11(file, "utf-8");
       if (content.length > 500000) {
         result.skipped.push(file + " (too large)");
         continue;
@@ -13806,7 +14335,7 @@ async function syncFromDir(dir, opts = {}) {
       const existing = allConfigs.find((c) => c.target_path === targetPath);
       if (!existing) {
         if (!opts.dryRun)
-          await store.createConfig({ name: relative5(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
+          await store.createConfig({ name: relative6(absDir, file), category: detectCategory(file), agent: detectAgent(file), target_path: targetPath, format: detectFormat(file), content });
         result.added++;
       } else if (existing.content !== content) {
         if (!opts.dryRun)
@@ -13823,7 +14352,7 @@ async function syncFromDir(dir, opts = {}) {
 }
 async function syncToDir(dir, opts = {}) {
   const store = opts.store ?? resolveConfigStore();
-  const home = homedir5();
+  const home = homedir7();
   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)));
@@ -13847,7 +14376,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const full = join10(dir, entry.name);
+    const full = join13(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -13908,7 +14437,7 @@ function isGeneratedOutputTarget2(config, owners) {
   return !!ownerIds && !ownerIds.has(config.id);
 }
 function hasClaudePromptSource() {
-  return existsSync11(expandPath("~/.claude/CLAUDE.md"));
+  return existsSync12(expandPath("~/.claude/CLAUDE.md"));
 }
 function hasClaudeRuleSourceForCursorTarget(targetPath) {
   const absoluteTargetPath = expandPath(targetPath);
@@ -13916,7 +14445,7 @@ function hasClaudeRuleSourceForCursorTarget(targetPath) {
   if (!absoluteTargetPath.startsWith(`${absolutePrefix}/`) || !absoluteTargetPath.endsWith(".mdc"))
     return false;
   const stem = basename5(absoluteTargetPath, ".mdc");
-  return existsSync11(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync11(expandPath(`~/.claude/rules/${stem}.mdc`));
+  return existsSync12(expandPath(`~/.claude/rules/${stem}.md`)) || existsSync12(expandPath(`~/.claude/rules/${stem}.mdc`));
 }
 function isKnownGeneratedTargetPath(targetPath) {
   const normalizedTargetPath = normalizeTargetPath(targetPath);
@@ -13981,11 +14510,11 @@ async function syncProject(opts) {
   const allConfigs = await store.listConfigs();
   const machine = detectMachineContext();
   for (const pf of PROJECT_CONFIG_FILES) {
-    const abs = join11(absDir, pf.file);
-    if (!existsSync11(abs))
+    const abs = join14(absDir, pf.file);
+    if (!existsSync12(abs))
       continue;
     try {
-      const rawContent = readFileSync10(abs, "utf-8");
+      const rawContent = readFileSync12(abs, "utf-8");
       if (rawContent.length > 500000) {
         result.skipped.push(pf.file);
         continue;
@@ -14014,20 +14543,20 @@ async function syncProject(opts) {
     }
   }
   for (const ruleDir of [
-    { dir: join11(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
-    { dir: join11(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
-    { dir: join11(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
-    { dir: join11(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
-    { dir: join11(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
-    { dir: join11(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
-    { dir: join11(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
+    { dir: join14(absDir, ".claude", "rules"), agent: "claude", namePrefix: "rules" },
+    { dir: join14(absDir, ".agents", "rules"), agent: "antigravity", namePrefix: "antigravity-rules" },
+    { dir: join14(absDir, ".cursor", "rules"), agent: "cursor", namePrefix: "cursor-rules" },
+    { dir: join14(absDir, ".github", "instructions"), agent: "copilot", namePrefix: "copilot-instructions" },
+    { dir: join14(absDir, ".devin", "rules"), agent: "devin", namePrefix: "devin-rules" },
+    { dir: join14(absDir, ".windsurf", "rules"), agent: "windsurf-legacy", namePrefix: "windsurf-rules" },
+    { dir: join14(absDir, ".clinerules"), agent: "cline", namePrefix: "cline-rules" }
   ]) {
-    if (!existsSync11(ruleDir.dir))
+    if (!existsSync12(ruleDir.dir))
       continue;
     const mdFiles = readdirSync3(ruleDir.dir).filter((f) => f.endsWith(".md") || f.endsWith(".mdc"));
     for (const f of mdFiles) {
-      const abs = join11(ruleDir.dir, f);
-      const raw = readFileSync10(abs, "utf-8");
+      const abs = join14(ruleDir.dir, f);
+      const raw = readFileSync12(abs, "utf-8");
       const redacted = redactContent(raw, "markdown");
       const machineAware = templateizeMachineContent(redacted.content, machine);
       const content = machineAware.content;
@@ -14066,20 +14595,20 @@ async function syncKnown(opts = {}) {
   for (const known of targets) {
     if (known.rulesDir) {
       const absDir = expandPath(known.rulesDir);
-      if (!existsSync11(absDir)) {
+      if (!existsSync12(absDir)) {
         result.skipped.push(known.rulesDir);
         continue;
       }
       const extensions = known.rulesExtensions ?? [".md", ".mdc"];
       const ruleFiles = readdirSync3(absDir).filter((f) => extensions.some((ext) => f.endsWith(ext)));
       for (const f of ruleFiles) {
-        const abs2 = join11(absDir, f);
+        const abs2 = join14(absDir, f);
         const targetPath = abs2.replace(home, "~");
         if (existingOutputOwners.has(normalizeTargetPath(targetPath)) || isKnownGeneratedTargetPath(targetPath)) {
           result.skipped.push(`${targetPath} (generated output)`);
           continue;
         }
-        const raw = readFileSync10(abs2, "utf-8");
+        const raw = readFileSync12(abs2, "utf-8");
         const redacted = redactContent(raw, "markdown");
         const machineAware = templateizeMachineContent(redacted.content, machine);
         const content = machineAware.content;
@@ -14107,12 +14636,12 @@ async function syncKnown(opts = {}) {
       continue;
     }
     const abs = expandPath(known.path);
-    if (!existsSync11(abs)) {
+    if (!existsSync12(abs)) {
       result.skipped.push(known.path);
       continue;
     }
     try {
-      const rawContent = normalizeKnownConfigSource(known, readFileSync10(abs, "utf-8"));
+      const rawContent = normalizeKnownConfigSource(known, readFileSync12(abs, "utf-8"));
       if (rawContent.length > 500000) {
         result.skipped.push(known.path + " (too large)");
         continue;
@@ -14215,9 +14744,9 @@ function storedPlaceholderIsLiteralOnDisk(storedLine, diskLine) {
 }
 function buildDiff(expectedContent, targetPath, storedFormat, showSecrets) {
   const path = expandPath(targetPath);
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return `(file not found on disk: ${path})`;
-  const diskContent = readFileSync10(path, "utf-8");
+  const diskContent = readFileSync12(path, "utf-8");
   if (diskContent === expectedContent)
     return "(no diff \u2014 identical)";
   const format = redactFormatForTarget(targetPath, storedFormat);
@@ -14375,26 +14904,26 @@ function detectFormat(filePath) {
   return "text";
 }
 // src/lib/export.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join12, resolve as resolve7 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join15, resolve as resolve10 } 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 = resolve7(outputPath);
-  const tmpDir = join12(tmpdir(), `configs-export-${Date.now()}`);
-  const contentsDir = join12(tmpDir, "contents");
+  const absOutput = resolve10(outputPath);
+  const tmpDir = join15(tmpdir(), `configs-export-${Date.now()}`);
+  const contentsDir = join15(tmpDir, "contents");
   try {
-    mkdirSync5(contentsDir, { recursive: true });
+    mkdirSync6(contentsDir, { recursive: true });
     const manifest = {
       version: "1.0.0",
       exported_at: new Date().toISOString(),
       configs: configs.map(({ content: _content, ...meta }) => meta)
     };
-    writeFileSync3(join12(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+    writeFileSync4(join15(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(join12(contentsDir, fileName), config.content, "utf-8");
+      writeFileSync4(join15(contentsDir, fileName), config.content, "utf-8");
     }
     const proc = Bun.spawn(["tar", "czf", absOutput, "-C", tmpDir, "."], {
       stdout: "pipe",
@@ -14407,23 +14936,23 @@ async function exportConfigs(outputPath, opts = {}) {
     }
     return { path: absOutput, count: configs.length };
   } finally {
-    if (existsSync12(tmpDir)) {
-      rmSync3(tmpDir, { recursive: true, force: true });
+    if (existsSync13(tmpDir)) {
+      rmSync4(tmpDir, { recursive: true, force: true });
     }
   }
 }
 // src/lib/import.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync4 } from "fs";
-import { join as join13, resolve as resolve8 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync13, rmSync as rmSync5 } from "fs";
+import { join as join16, resolve as resolve11 } 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 = resolve8(bundlePath);
-  const tmpDir = join13(tmpdir2(), `configs-import-${Date.now()}`);
+  const absPath = resolve11(bundlePath);
+  const tmpDir = join16(tmpdir2(), `configs-import-${Date.now()}`);
   const result = { created: 0, updated: 0, skipped: 0, errors: [] };
   try {
-    mkdirSync6(tmpDir, { recursive: true });
+    mkdirSync7(tmpDir, { recursive: true });
     const proc = Bun.spawn(["tar", "xzf", absPath, "-C", tmpDir], {
       stdout: "pipe",
       stderr: "pipe"
@@ -14433,15 +14962,15 @@ async function importConfigs(bundlePath, opts = {}) {
       const stderr = await new Response(proc.stderr).text();
       throw new Error(`tar extraction failed: ${stderr}`);
     }
-    const manifestPath = join13(tmpDir, "manifest.json");
-    if (!existsSync13(manifestPath))
+    const manifestPath = join16(tmpDir, "manifest.json");
+    if (!existsSync14(manifestPath))
       throw new Error("Invalid bundle: missing manifest.json");
-    const manifest = JSON.parse(readFileSync11(manifestPath, "utf-8"));
+    const manifest = JSON.parse(readFileSync13(manifestPath, "utf-8"));
     for (const meta of manifest.configs) {
       try {
         const ext = meta.format === "text" ? "txt" : meta.format;
-        const contentFile = join13(tmpDir, "contents", `${meta.slug}.${ext}`);
-        const content = existsSync13(contentFile) ? readFileSync11(contentFile, "utf-8") : "";
+        const contentFile = join16(tmpDir, "contents", `${meta.slug}.${ext}`);
+        const content = existsSync14(contentFile) ? readFileSync13(contentFile, "utf-8") : "";
         let existing = null;
         try {
           existing = await store.getConfig(meta.slug);
@@ -14475,16 +15004,16 @@ async function importConfigs(bundlePath, opts = {}) {
     }
     return result;
   } finally {
-    if (existsSync13(tmpDir)) {
-      rmSync4(tmpDir, { recursive: true, force: true });
+    if (existsSync14(tmpDir)) {
+      rmSync5(tmpDir, { recursive: true, force: true });
     }
   }
 }
 // src/lib/package-manager-guard.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync14, lstatSync as lstatSync4, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "fs";
-import { homedir as homedir6 } from "os";
-import { basename as basename6, dirname as dirname7, isAbsolute as isAbsolute5, join as join14, relative as relative6, resolve as resolve9 } from "path";
+import { existsSync as existsSync15, lstatSync as lstatSync6, readdirSync as readdirSync4, readFileSync as readFileSync14 } from "fs";
+import { homedir as homedir8 } from "os";
+import { basename as basename6, dirname as dirname8, isAbsolute as isAbsolute5, join as join17, relative as relative7, resolve as resolve12 } from "path";
 var SKIP_DIRS = new Set([
   ".git",
   "node_modules",
@@ -14515,20 +15044,20 @@ var HOME_FILES = [
 var TOKEN_VALUE_PATTERNS = [
   { re: /npm_[A-Za-z0-9]{36,}/, rule: "literal-npm-token", detail: "literal npm token-like value" },
   { re: /gh[pousr]_[A-Za-z0-9_]{36,}/, rule: "literal-github-token", detail: "literal GitHub token-like value" },
-  { re: /sk-ant-[A-Za-z0-9\-_]{40,}/, rule: "literal-anthropic-key", detail: "literal Anthropic key-like value" },
+  { re: /sk[-]ant-[A-Za-z0-9\-_]{40,}/, rule: "literal-anthropic-key", detail: "literal Anthropic key-like value" },
   { re: /sk-[A-Za-z0-9]{48,}/, rule: "literal-openai-key", detail: "literal OpenAI key-like value" },
   { re: /AKIA[0-9A-Z]{16}/, rule: "literal-aws-access-key", detail: "literal AWS access-key-like value" },
   { re: /xoxb-[0-9]+-[A-Za-z0-9-]+/, rule: "literal-slack-token", detail: "literal Slack token-like value" }
 ];
 function scanPackageManagerSecrets(options = {}) {
-  const cwd = options.cwd ? resolve9(options.cwd) : process.cwd();
-  const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve9(cwd, root));
+  const cwd = options.cwd ? resolve12(options.cwd) : process.cwd();
+  const roots = (options.roots && options.roots.length > 0 ? options.roots : [cwd]).map((root) => resolve12(cwd, root));
   const findings = [];
   let scannedFiles = 0;
   for (const root of roots) {
-    if (!existsSync14(root))
+    if (!existsSync15(root))
       continue;
-    const stat = lstatSync4(root);
+    const stat = lstatSync6(root);
     if (stat.isFile()) {
       if (!shouldScanRepoFile(root))
         continue;
@@ -14536,14 +15065,14 @@ function scanPackageManagerSecrets(options = {}) {
       if (text === null)
         continue;
       scannedFiles++;
-      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname7(root)));
+      findings.push(...scanFile(root, text, classifyRepoFile(root), isTrackedFile(root), dirname8(root)));
       continue;
     }
     if (!stat.isDirectory())
       continue;
     const tracked = trackedFiles(root);
     for (const file of collectRepoFiles(root)) {
-      const rel = toPosix(relative6(root, file));
+      const rel = toPosix(relative7(root, file));
       const isTracked = tracked.has(rel);
       const text = readTextFile(file);
       if (text === null)
@@ -14553,10 +15082,10 @@ function scanPackageManagerSecrets(options = {}) {
     }
   }
   if (options.includeHome) {
-    const home = homedir6();
+    const home = homedir8();
     for (const name of HOME_FILES) {
-      const file = join14(home, name);
-      if (!existsSync14(file))
+      const file = join17(home, name);
+      if (!existsSync15(file))
         continue;
       const text = readTextFile(file);
       if (text === null)
@@ -14580,12 +15109,12 @@ function collectRepoFiles(root) {
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name))
           continue;
-        visit(join14(dir, entry.name));
+        visit(join17(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const file = join14(dir, entry.name);
+      const file = join17(dir, entry.name);
       if (shouldScanRepoFile(file))
         out.push(file);
     }
@@ -14620,10 +15149,10 @@ function isNpmrcName(name) {
 }
 function readTextFile(file) {
   try {
-    const stat = lstatSync4(file);
+    const stat = lstatSync6(file);
     if (!stat.isFile() || stat.size > 5000000)
       return null;
-    const buf = readFileSync12(file);
+    const buf = readFileSync14(file);
     if (buf.includes(0))
       return null;
     return buf.toString("utf-8");
@@ -14823,11 +15352,11 @@ function trackedFiles(root) {
 }
 function isTrackedFile(file) {
   try {
-    const repoRoot = execFileSync2("git", ["-C", dirname7(file), "rev-parse", "--show-toplevel"], {
+    const repoRoot = execFileSync2("git", ["-C", dirname8(file), "rev-parse", "--show-toplevel"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    const rel = toPosix(relative6(repoRoot, file));
+    const rel = toPosix(relative7(repoRoot, file));
     execFileSync2("git", ["-C", repoRoot, "ls-files", "--error-unmatch", "--", rel], {
       stdio: ["ignore", "ignore", "ignore"]
     });
@@ -14853,172 +15382,176 @@ function stripInlineComment(value) {
   return value.replace(/\s[#;].*$/, "").trim();
 }
 function displayPath(file, root) {
-  const home = homedir6();
+  const home = homedir8();
   if (root === home && (file === home || file.startsWith(home + "/")))
-    return "~/" + toPosix(relative6(home, file));
+    return "~/" + toPosix(relative7(home, file));
   if (isAbsolute5(root) && file.startsWith(root + "/"))
-    return toPosix(relative6(root, file));
+    return toPosix(relative7(root, file));
   if (file === home || file.startsWith(home + "/"))
-    return "~/" + toPosix(relative6(home, file));
+    return "~/" + toPosix(relative7(home, file));
   return file;
 }
 function toPosix(path) {
   return path.split("\\").join("/");
 }
 export {
-  uuid,
-  transformSkillContent,
-  templateizeMachineContent,
-  syncToDisk,
-  syncToDir,
-  syncProject,
-  syncKnown,
-  syncFromDir,
-  stripClaudeOnlySections,
-  sourcesFromIdentityExport,
-  sourceFromFilePath,
-  sourceFromConfig,
-  slugify,
-  selectProviderCapability,
-  selectProfileConfigsForSessionRender,
-  selectAssetCapability,
-  scanSecrets,
-  scanPackageManagerSecrets,
-  restoreSessionRenderSnapshot,
-  resolveSessionTargetOwnership,
-  resolveSessionPath,
-  resolveProfileVariables,
-  resolveConfigStore,
-  resolveCloudConfig,
-  resolveAssetDestination,
-  resolveAgentOperatingRulesPayload,
-  renderTemplatePreview,
-  renderTemplate,
-  renderMachineAwareContentPreview,
-  renderMachineAwareContent,
-  redactContent,
-  providerVersionSatisfies,
-  previewConfigs,
-  planSessionRender,
-  planProjectContext,
-  planProfileSessionRender,
-  parseTemplateVars,
-  parseProjectContextBundle,
-  parseAgentOperatingRulesVersion,
-  now,
-  normalizeProfileConfigBinding,
-  normalizeProfileAssetBinding,
-  normalizeOsFamily,
-  normalizeBoundedReadOptions,
-  machineContextToVariables,
-  legacyProfileConfigBinding,
-  isTemplate,
-  isCloudMode,
-  importConfigs,
-  hasSecrets,
-  getConfigsStatus,
-  extractTemplateVars,
-  exportConfigs,
-  expandPath,
-  ensureProjectDashboardStandardConfig,
-  ensurePlatformProfiles,
-  ensureGlobalAgentRulesStandardConfig,
-  ensureDangerousOperationGuardStandardConfig,
-  ensureCodewithSharedTodosStorageStandardConfig,
-  diffConfig,
-  detectMachineContext,
-  detectFormat,
-  detectCategory,
-  detectAgent,
-  currentOs,
-  currentHostname2 as currentHostname,
-  currentArch2 as currentArch,
-  configAssetLocator,
-  configAssetDigest,
-  computeProjectContextSourceHash,
-  compileInstructionGraph,
-  compileAssetPlan,
-  compareAgentOperatingRulesVersions,
-  cleanSessionPathInput,
-  checkSessionRenderDrift,
-  buildOpenCodeAgentsMd,
-  buildCursorMdc,
-  buildCodexAgentsMd,
-  boundedReadPage,
-  assetBundleFromConfig,
-  applyTransform,
-  applySessionRender,
-  applyProjectContext,
-  applyConfigsWithReport,
-  applyConfigs,
-  applyConfig,
-  TemplateRenderError,
-  SessionApplyError,
-  SESSION_TOOL_ADAPTERS,
-  SESSION_RENDER_TOOLS,
-  SESSION_RENDER_SCHEMA,
-  SESSION_RENDER_MANAGED_MARKER,
-  SESSION_LAYER_RANK,
-  SESSION_INSTRUCTION_LAYERS,
-  RAW_STORE_ROOT_ENV,
-  ProjectContextError,
-  ProfileNotFoundError,
-  PROVIDER_CAPABILITY_SCHEMA,
-  PROVIDER_CAPABILITY_DESCRIPTORS,
-  PROVIDER_CAPABILITIES,
-  PROJECT_DASHBOARD_STANDARD_SLUG,
-  PROJECT_DASHBOARD_STANDARD_CONTENT,
-  PROJECT_DASHBOARD_PROFILE_VARIABLES,
-  PROJECT_CONTEXT_SCHEMA,
-  PROJECT_CONTEXT_MAX_RENDERED_BYTES,
-  PROJECT_CONTEXT_MAX_INPUT_BYTES,
-  PROJECT_CONTEXT_MAX_COMMANDS,
-  PROJECT_CONTEXT_MANIFEST_PATH,
-  PROJECT_CONTEXT_MANAGED_COMMENT,
-  PROJECT_CONTEXT_LOCK_PATH,
-  PROJECT_CONTEXT_FRAGMENT_PATH,
-  PROJECT_CONTEXT_CACHE_PATH,
-  PROJECT_CONFIG_FILES,
-  PROFILE_CONFIG_BINDING_SCHEMA,
-  PROFILE_ASSET_BINDING_SCHEMA,
-  PLATFORM_PROFILE_PRESETS,
-  PG_MIGRATIONS,
-  LocalConfigStore,
-  LEGACY_CONFIGS_PACKAGE,
-  LEGACY_CONFIGS_EXECUTABLE,
-  LEGACY_CONFIGS_COMPAT_VERSION,
-  KNOWN_CONFIGS,
-  InstructionGraphValidationError,
-  INSTRUCTION_GRAPH_PLAN_SCHEMA,
-  INSTRUCTION_FALLBACKS,
-  INSTRUCTION_ACTIVATION_MODES,
-  GLOBAL_AGENT_RULES_STANDARD_SLUG,
-  GLOBAL_AGENT_RULES_STANDARD_CONTENT,
-  DANGEROUS_OPERATION_GUARD_STANDARD_SLUG,
-  DANGEROUS_OPERATION_GUARD_STANDARD_CONTENT,
-  ConfigNotFoundError,
-  ConfigApplyError,
-  CloudHttpError,
-  CloudConfigStore,
-  CONFIG_TRANSFORMS,
-  CONFIG_KINDS,
-  CONFIG_FORMATS,
-  CONFIG_CATEGORIES,
-  CONFIG_AGENTS,
-  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_SLUG,
-  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_CONTENT,
-  CODEWITH_SHARED_TODOS_STORAGE_POLICY_REFERENCE,
-  CODEWITH_NATIVE_IMPORTS_ENV,
-  AssetPlanValidationError,
-  ASSET_UNINSTALL_POLICIES,
-  ASSET_SCOPES,
-  ASSET_ROLLBACK_POLICIES,
-  ASSET_PLAN_SCHEMA,
-  ASSET_KINDS,
-  ASSET_DESTINATION_STRATEGIES,
-  ASSET_CAPABILITY_SCHEMA,
-  ASSET_CAPABILITY_DESCRIPTORS,
-  ASSET_BUNDLE_SCHEMA,
+  AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY,
   AGENT_OPERATING_RULES_SENTINEL_PATTERN,
-  AGENT_OPERATING_RULES_SEMANTIC_POLICY_KEY
+  ASSET_BUNDLE_SCHEMA,
+  ASSET_CAPABILITY_DESCRIPTORS,
+  ASSET_CAPABILITY_SCHEMA,
+  ASSET_DESTINATION_STRATEGIES,
+  ASSET_KINDS,
+  ASSET_PLAN_SCHEMA,
+  ASSET_ROLLBACK_POLICIES,
+  ASSET_SCOPES,
+  ASSET_UNINSTALL_POLICIES,
+  AssetPlanValidationError,
+  CODEWITH_NATIVE_IMPORTS_ENV,
+  CODEWITH_SHARED_TODOS_STORAGE_POLICY_REFERENCE,
+  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_CONTENT,
+  CODEWITH_SHARED_TODOS_STORAGE_STANDARD_SLUG,
+  CONFIG_AGENTS,
+  CONFIG_CATEGORIES,
+  CONFIG_FORMATS,
+  CONFIG_KINDS,
+  CONFIG_TRANSFORMS,
+  CloudConfigStore,
+  CloudHttpError,
+  ConfigApplyError,
+  ConfigNotFoundError,
+  DANGEROUS_OPERATION_GUARD_STANDARD_CONTENT,
+  DANGEROUS_OPERATION_GUARD_STANDARD_SLUG,
+  GLOBAL_AGENT_RULES_STANDARD_CONTENT,
+  GLOBAL_AGENT_RULES_STANDARD_SLUG,
+  INBOX_CONVERSATIONS_MINIMUM_VERSION,
+  INSTRUCTION_ACTIVATION_MODES,
+  INSTRUCTION_FALLBACKS,
+  INSTRUCTION_GRAPH_PLAN_SCHEMA,
+  InstructionGraphValidationError,
+  KNOWN_CONFIGS,
+  LEGACY_CONFIGS_COMPAT_VERSION,
+  LEGACY_CONFIGS_EXECUTABLE,
+  LEGACY_CONFIGS_PACKAGE,
+  LocalConfigStore,
+  PG_MIGRATIONS,
+  PLATFORM_PROFILE_PRESETS,
+  PROFILE_ASSET_BINDING_SCHEMA,
+  PROFILE_CONFIG_BINDING_SCHEMA,
+  PROJECT_CONFIG_FILES,
+  PROJECT_CONTEXT_CACHE_PATH,
+  PROJECT_CONTEXT_FRAGMENT_PATH,
+  PROJECT_CONTEXT_LOCK_PATH,
+  PROJECT_CONTEXT_MANAGED_COMMENT,
+  PROJECT_CONTEXT_MANIFEST_PATH,
+  PROJECT_CONTEXT_MAX_COMMANDS,
+  PROJECT_CONTEXT_MAX_INPUT_BYTES,
+  PROJECT_CONTEXT_MAX_RENDERED_BYTES,
+  PROJECT_CONTEXT_SCHEMA,
+  PROJECT_DASHBOARD_PROFILE_VARIABLES,
+  PROJECT_DASHBOARD_STANDARD_CONTENT,
+  PROJECT_DASHBOARD_STANDARD_SLUG,
+  PROVIDER_CAPABILITIES,
+  PROVIDER_CAPABILITY_DESCRIPTORS,
+  PROVIDER_CAPABILITY_SCHEMA,
+  ProfileNotFoundError,
+  ProjectContextError,
+  RAW_STORE_ROOT_ENV,
+  SESSION_INSTRUCTION_LAYERS,
+  SESSION_LAYER_RANK,
+  SESSION_RENDER_MANAGED_MARKER,
+  SESSION_RENDER_SCHEMA,
+  SESSION_RENDER_TOOLS,
+  SESSION_TOOL_ADAPTERS,
+  SessionApplyError,
+  TemplateRenderError,
+  applyConfig,
+  applyConfigs,
+  applyConfigsWithReport,
+  applyProjectContext,
+  applySessionRender,
+  applyTransform,
+  assetBundleFromConfig,
+  boundedReadPage,
+  buildCodexAgentsMd,
+  buildCursorMdc,
+  buildOpenCodeAgentsMd,
+  checkSessionRenderDrift,
+  cleanSessionPathInput,
+  compareAgentOperatingRulesVersions,
+  compileAssetPlan,
+  compileInstructionGraph,
+  computeProjectContextSourceHash,
+  configAssetDigest,
+  configAssetLocator,
+  currentArch2 as currentArch,
+  currentHostname2 as currentHostname,
+  currentOs,
+  detectAgent,
+  detectCategory,
+  detectFormat,
+  detectMachineContext,
+  diffConfig,
+  ensureCodewithSharedTodosStorageStandardConfig,
+  ensureDangerousOperationGuardStandardConfig,
+  ensureGlobalAgentRulesStandardConfig,
+  ensurePlatformProfiles,
+  ensureProjectDashboardStandardConfig,
+  expandPath,
+  exportConfigs,
+  extractTemplateVars,
+  getConfigsStatus,
+  getRawStoreRoot,
+  hasSecrets,
+  importConfigs,
+  inspectManagedSkillRuntimes,
+  isApiTransport,
+  isTemplate,
+  legacyProfileConfigBinding,
+  machineContextToVariables,
+  normalizeBoundedReadOptions,
+  normalizeOsFamily,
+  normalizeProfileAssetBinding,
+  normalizeProfileConfigBinding,
+  now,
+  parseAgentOperatingRulesVersion,
+  parseProjectContextBundle,
+  parseTemplateVars,
+  planProfileSessionRender,
+  planProjectContext,
+  planSessionRender,
+  previewConfigs,
+  providerVersionSatisfies,
+  reconcileManagedSkillRuntimes,
+  redactContent,
+  renderMachineAwareContent,
+  renderMachineAwareContentPreview,
+  renderTemplate,
+  renderTemplatePreview,
+  resolveAgentOperatingRulesPayload,
+  resolveAssetDestination,
+  resolveCloudConfig,
+  resolveConfigStore,
+  resolveProfileVariables,
+  resolveSessionPath,
+  resolveSessionTargetOwnership,
+  restoreSessionRenderSnapshot,
+  scanPackageManagerSecrets,
+  scanSecrets,
+  selectAssetCapability,
+  selectProfileConfigsForSessionRender,
+  selectProviderCapability,
+  slugify,
+  sourceFromConfig,
+  sourceFromFilePath,
+  sourcesFromIdentityExport,
+  stripClaudeOnlySections,
+  syncFromDir,
+  syncKnown,
+  syncProject,
+  syncToDir,
+  syncToDisk,
+  templateizeMachineContent,
+  transformSkillContent,
+  uuid
 };