@hasna/skills 0.10.1 → 0.10.2

package/bin/index.js

@@ -36868,7 +36868,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.10.1",
+    version: "0.10.2",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -49704,7 +49704,9 @@ var init_skill_version = __esm(() => {
 
 // src/lib/selection-cache.ts
 import { createHash as createHash7, randomUUID as randomUUID3 } from "crypto";
-import { closeSync as closeSync6, constants as constants4, fstatSync as fstatSync6, fsyncSync, lstatSync as lstatSync9, mkdirSync as mkdirSync3, openSync as openSync6, readSync as readSync3, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { closeSync as closeSync6, constants as constants4, fstatSync as fstatSync6, fsyncSync, lstatSync as lstatSync9, mkdirSync as mkdirSync3, openSync as openSync6, readFileSync as readFileSync10, readlinkSync as readlinkSync2, readSync as readSync3, renameSync, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { hostname } from "os";
 import { dirname as dirname8, join as join16, parse as parse2, resolve as resolve8 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 function selectionCacheRoot(options = {}) {
@@ -49986,6 +49988,201 @@ function readSkillSessionSnapshot(sessionId, options = {}) {
 function skillSessionSnapshotBinding(snapshot) {
   return { sessionId: snapshot.sessionId, generation: snapshot.generation, receiptSha256: snapshot.receiptSha256 };
 }
+function localBootId() {
+  try {
+    if (process.platform === "linux") {
+      const value = readFileSync10("/proc/sys/kernel/random/boot_id", "utf8").trim();
+      return /^[a-f0-9-]{36}$/i.test(value) ? value : null;
+    }
+    if (process.platform === "darwin") {
+      const result2 = spawnSync2("/usr/sbin/sysctl", ["-n", "kern.boottime"], { encoding: "utf8", timeout: 3000, env: { LC_ALL: "C" } });
+      if (result2.status !== 0 || result2.error)
+        return null;
+      const seconds = /\bsec\s*=\s*(\d+)\b/.exec(result2.stdout)?.[1];
+      return seconds ? `darwin:${seconds}` : null;
+    }
+  } catch {}
+  return null;
+}
+function processStart(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return { state: "unknown" };
+  if (process.platform === "linux") {
+    try {
+      const stat = readFileSync10(`/proc/${pid}/stat`, "utf8");
+      const close = stat.lastIndexOf(")");
+      const start = close < 0 ? undefined : stat.slice(close + 2).trim().split(/\s+/)[19];
+      return start && /^\d+$/.test(start) ? { state: "alive", start: `linux:${start}` } : { state: "unknown" };
+    } catch (error) {
+      return { state: error.code === "ENOENT" ? "absent" : "unknown" };
+    }
+  }
+  if (process.platform === "darwin") {
+    const result2 = spawnSync2("/bin/ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8", timeout: 3000, env: { LC_ALL: "C" } });
+    if (result2.error || result2.signal)
+      return { state: "unknown" };
+    const start = result2.stdout.trim();
+    if (result2.status === 1 && !start && !result2.stderr.trim())
+      return { state: "absent" };
+    return result2.status === 0 && start ? { state: "alive", start: `darwin:${start}` } : { state: "unknown" };
+  }
+  return { state: "unknown" };
+}
+function localLockIdentity() {
+  const bootId = localBootId(), owner = processStart(process.pid);
+  if (!bootId || owner.state !== "alive")
+    return null;
+  let pidNamespace;
+  if (process.platform === "linux") {
+    try {
+      pidNamespace = readlinkSync2("/proc/self/ns/pid");
+    } catch {
+      return null;
+    }
+    if (!/^pid:\[\d+\]$/.test(pidNamespace))
+      return null;
+  }
+  return { host: hostname(), bootId, pidNamespace, processStart: owner.start };
+}
+function readSessionLock(sessionId, options) {
+  const path = `${sessionReceiptPath(sessionId, options)}.write-lock`;
+  const before2 = lstatSync9(path, { throwIfNoEntry: false });
+  if (!before2)
+    return null;
+  if (!before2.isFile() || before2.nlink !== 1 || process.getuid && before2.uid !== process.getuid()) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is not a private regular file; recovery requires review.");
+  }
+  const bytes = readRegularFile(path, SESSION_LOCK_MAX_BYTES);
+  const after2 = lstatSync9(path, { throwIfNoEntry: false });
+  if (!bytes || !after2?.isFile() || before2.dev !== after2.dev || before2.ino !== after2.ino || before2.mtimeMs !== after2.mtimeMs) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock changed during inspection; recovery requires review.");
+  }
+  let marker;
+  try {
+    marker = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock is unreadable; recovery requires review.");
+  }
+  if (!marker || ![1, 2].includes(marker.schemaVersion) || marker.sessionId !== sessionId || !/^[a-f0-9-]{36}$/i.test(marker.operationId) || !Number.isSafeInteger(marker.pid) || marker.pid <= 0 || marker.schemaVersion === 2 && (!marker.host || !marker.bootId || !marker.processStart || process.platform === "linux" && !marker.pidNamespace)) {
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The session lock has invalid ownership metadata; recovery requires review.");
+  }
+  return { path, bytes, marker, sha256: sha256Hex(bytes), dev: after2.dev, ino: after2.ino, mtimeMs: after2.mtimeMs };
+}
+function writerIsGone(lock, explicitLocalHost) {
+  if (Date.now() - lock.mtimeMs < SESSION_LOCK_MIN_AGE_MS)
+    return false;
+  const owner = processStart(lock.marker.pid);
+  if (owner.state === "unknown")
+    return false;
+  if (lock.marker.schemaVersion === 1)
+    return explicitLocalHost && owner.state === "absent";
+  const local = localLockIdentity();
+  if (!local || lock.marker.host !== local.host || lock.marker.bootId !== local.bootId || lock.marker.pidNamespace !== local.pidNamespace)
+    return false;
+  return owner.state === "absent" || owner.state === "alive" && owner.start !== lock.marker.processStart;
+}
+function lockReviewDigest(lock, receipt) {
+  return hash({
+    sessionId: lock.marker.sessionId,
+    lockSha256: lock.sha256,
+    lockDev: lock.dev,
+    lockIno: lock.ino,
+    lockMtimeMs: lock.mtimeMs,
+    receiptSha256: receipt?.sha256 ?? null,
+    receiptGeneration: receipt?.generation ?? null
+  });
+}
+function inspectSessionWriteLock(sessionId, options = {}) {
+  const receipt = readSkillSessionSnapshotIfExists(sessionId, options), lock = readSessionLock(sessionId, options);
+  if (!lock)
+    throw new SkillSelectionError("SESSION_WRITE_LOCK_NOT_FOUND", "The session has no write lock to recover.");
+  return {
+    sessionId,
+    schemaVersion: lock.marker.schemaVersion,
+    pid: lock.marker.pid,
+    lockSha256: lock.sha256,
+    lockMtime: new Date(lock.mtimeMs).toISOString(),
+    receiptSha256: receipt?.sha256 ?? null,
+    receiptGeneration: receipt?.generation ?? null,
+    reviewDigest: lockReviewDigest(lock, receipt),
+    hostBound: lock.marker.schemaVersion === 2
+  };
+}
+function archiveSessionLock(lock, receipt, explicitLocalHost) {
+  const guardPath = `${lock.path}.recovery-guard`;
+  let guardFd;
+  try {
+    guardFd = openSync6(guardPath, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 384);
+  } catch (error) {
+    if (error.code === "EEXIST")
+      return null;
+    throw error;
+  }
+  const guardStat = fstatSync6(guardFd);
+  try {
+    writeFileSync3(guardFd, `${JSON.stringify({ schemaVersion: 1, pid: process.pid, operationId: randomUUID3() })}
+`);
+    fsyncSync(guardFd);
+    const cacheOptions = { cacheDir: dirname8(dirname8(lock.path)) };
+    const current = readSessionLock(lock.marker.sessionId, cacheOptions);
+    if (!current || current.dev !== lock.dev || current.ino !== lock.ino || current.sha256 !== lock.sha256 || current.mtimeMs !== lock.mtimeMs || !writerIsGone(current, explicitLocalHost))
+      return null;
+    const currentReceipt = readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions);
+    if (currentReceipt?.sha256 !== receipt?.sha256 || currentReceipt?.generation !== receipt?.generation)
+      return null;
+    const directory = join16(dirname8(dirname8(lock.path)), "session-lock-recoveries", randomUUID3());
+    const archivePath = join16(directory, "original.write-lock");
+    const recordPath = join16(directory, "recovery.json");
+    assertRegularPath(archivePath, true);
+    archiveBytes(recordPath, Buffer.from(`${JSON.stringify({
+      schemaVersion: 1,
+      sessionId: lock.marker.sessionId,
+      originalPath: lock.path,
+      lockSha256: lock.sha256,
+      lockMtime: new Date(lock.mtimeMs).toISOString(),
+      lockPid: lock.marker.pid,
+      receiptSha256: receipt?.sha256 ?? null,
+      receiptGeneration: receipt?.generation ?? null,
+      status: "prepared"
+    })}
+`));
+    syncDirectory(directory);
+    syncDirectory(dirname8(directory));
+    const finalLock = readSessionLock(lock.marker.sessionId, cacheOptions);
+    if (!finalLock || finalLock.dev !== lock.dev || finalLock.ino !== lock.ino || finalLock.sha256 !== lock.sha256 || readSkillSessionSnapshotIfExists(lock.marker.sessionId, cacheOptions)?.sha256 !== receipt?.sha256)
+      return null;
+    let moved = false;
+    try {
+      renameSync(lock.path, archivePath);
+      moved = true;
+      syncDirectory(directory);
+      syncDirectory(dirname8(lock.path));
+      if (sha256Hex(readRegularFile(archivePath, SESSION_LOCK_MAX_BYTES)) !== lock.sha256) {
+        throw new Error("Archived lock bytes changed");
+      }
+    } catch (error) {
+      if (moved)
+        throw new SkillSelectionError("SESSION_LOCK_RECOVERY_INCOMPLETE", "The lock moved, but durable recovery could not be confirmed; inspect the preserved recovery directory and session receipt.");
+      throw error;
+    }
+    return archivePath;
+  } finally {
+    closeSync6(guardFd);
+    const current = lstatSync9(guardPath, { throwIfNoEntry: false });
+    if (current?.isFile() && current.dev === guardStat.dev && current.ino === guardStat.ino)
+      unlinkSync(guardPath);
+  }
+}
+function recoverSessionWriteLock(sessionId, reviewDigest, options = {}) {
+  const receipt = readSkillSessionSnapshotIfExists(sessionId, options), lock = readSessionLock(sessionId, options);
+  if (!lock || lockReviewDigest(lock, receipt) !== reviewDigest) {
+    throw new SkillSelectionError("SESSION_LOCK_REVIEW_CHANGED", "The lock or receipt changed after review; inspect the session lock again.");
+  }
+  const archivePath = archiveSessionLock(lock, receipt, true);
+  if (!archivePath)
+    throw new SkillSelectionError("SESSION_WRITE_LOCKED", "The lock is live, too recent, or changed during recovery; leave it in place and inspect again.");
+  return archivePath;
+}
 function withSessionWriteLocks(sessionIds, options, action) {
   const operationId = randomUUID3();
   const locks = [...new Set(sessionIds)].map((sessionId) => ({ sessionId, path: `${sessionReceiptPath(sessionId, options)}.write-lock` })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
@@ -50005,13 +50202,30 @@ function withSessionWriteLocks(sessionIds, options, action) {
       try {
         fd = openSync6(lock.path, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 384);
       } catch (error) {
-        if (error.code === "EEXIST")
-          throw new SkillSelectionError("SESSION_WRITE_LOCKED", "Another Skills process owns a required session write lock; retry after it completes. A surviving lock requires explicit recovery review.");
-        throw error;
+        if (error.code !== "EEXIST")
+          throw error;
+        try {
+          const stale = readSessionLock(lock.sessionId, options);
+          const receipt = stale && readSkillSessionSnapshotIfExists(lock.sessionId, options);
+          if (stale?.marker.schemaVersion === 2 && writerIsGone(stale, false)) {
+            archiveSessionLock(stale, receipt, false);
+          }
+        } catch (recoveryError) {
+          if (recoveryError instanceof SkillSelectionError && recoveryError.code === "SESSION_LOCK_RECOVERY_INCOMPLETE")
+            throw recoveryError;
+        }
+        try {
+          fd = openSync6(lock.path, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW, 384);
+        } catch (retryError) {
+          if (retryError.code === "EEXIST")
+            throw new SkillSelectionError("SESSION_WRITE_LOCKED", "Another Skills process owns a required session write lock; retry after it completes. A surviving legacy lock requires explicit recovery review.");
+          throw retryError;
+        }
       }
       const stat = fstatSync6(fd);
       owned.push({ path: lock.path, fd, dev: stat.dev, ino: stat.ino });
-      writeFileSync3(fd, `${JSON.stringify({ schemaVersion: 1, operationId, sessionId: lock.sessionId, pid: process.pid })}
+      const identity4 = localLockIdentity();
+      writeFileSync3(fd, `${JSON.stringify({ schemaVersion: identity4 ? 2 : 1, operationId, sessionId: lock.sessionId, pid: process.pid, ...identity4 })}
 `);
     }
     return action(assertOwned);
@@ -50128,7 +50342,7 @@ function replaceSkillSession(expected, replacement, plan, options = {}, beforeCo
     return { archivePath, receiptPath, beforeSha256: before2.sha256, afterSha256 };
   });
 }
-var SkillSelectionError, MAX_CACHED_PROFILE_AGE_MS, SELECTION_LOCK_FILE = "selection.lock.json";
+var SkillSelectionError, MAX_CACHED_PROFILE_AGE_MS, SELECTION_LOCK_FILE = "selection.lock.json", SESSION_LOCK_MAX_BYTES = 4096, SESSION_LOCK_MIN_AGE_MS = 30000;
 var init_selection_cache = __esm(() => {
   init_config();
   init_skill_bundle();
@@ -50186,7 +50400,7 @@ function capturePreparationProcess(child, platform2 = process.platform, signalGr
 }
 
 // src/lib/dependency-preparation.ts
-import { constants as constants5, closeSync as closeSync7, fstatSync as fstatSync7, lstatSync as lstatSync10, mkdirSync as mkdirSync4, openSync as openSync7, readFileSync as readFileSync10, readdirSync as readdirSync5, rmdirSync, unlinkSync as unlinkSync2, ftruncateSync, writeSync } from "fs";
+import { constants as constants5, closeSync as closeSync7, fstatSync as fstatSync7, lstatSync as lstatSync10, mkdirSync as mkdirSync4, openSync as openSync7, readFileSync as readFileSync11, readdirSync as readdirSync5, rmdirSync, unlinkSync as unlinkSync2, ftruncateSync, writeSync } from "fs";
 import { join as join17 } from "path";
 function hasDependencyPreparationMarker(skillPath) {
   try {
@@ -50216,7 +50430,7 @@ function claimPreparation(skillPath) {
         return;
       if (!lstatSync10(state).isFile() || lstatSync10(state).isSymbolicLink() || lstatSync10(state).size > 1024)
         return;
-      const previous = JSON.parse(readFileSync10(state, "utf8"));
+      const previous = JSON.parse(readFileSync11(state, "utf8"));
       if (previous.version !== 1 || previous.status !== "failed" || Object.keys(previous).length !== 2)
         return;
     }
@@ -50436,7 +50650,7 @@ var init_managed_policy = __esm(() => {
 
 // src/lib/agent-bridge.ts
 import { createHash as createHash8 } from "crypto";
-import { lstatSync as lstatSync12, readFileSync as readFileSync11, readdirSync as readdirSync6 } from "fs";
+import { lstatSync as lstatSync12, readFileSync as readFileSync12, readdirSync as readdirSync6 } from "fs";
 import { join as join19 } from "path";
 function isOwnedCliBridge(path, expectedPaths) {
   if (!expectedPaths.includes(path))
@@ -50448,7 +50662,7 @@ function isOwnedCliBridge(path, expectedPaths) {
       return false;
     return Object.entries(CLI_BRIDGE_FILES).every(([name, content]) => {
       const file = join19(path, name), stat = lstatSync12(file);
-      return stat.isFile() && !stat.isSymbolicLink() && stat.size === Buffer.byteLength(content) && readFileSync11(file, "utf8") === content;
+      return stat.isFile() && !stat.isSymbolicLink() && stat.size === Buffer.byteLength(content) && readFileSync12(file, "utf8") === content;
     });
   } catch {
     return false;
@@ -50822,7 +51036,7 @@ var init_claude_settings_witness = __esm(() => {
 
 // src/lib/agent-integration.ts
 import { createHash as createHash10, randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync12, lstatSync as lstatSync14, statSync as statSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync12, readdirSync as readdirSync7, opendirSync as opendirSync3, readlinkSync as readlinkSync2, realpathSync as realpathSync3, renameSync as renameSync2, rmdirSync as rmdirSync2, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, chmodSync, openSync as openSync10, closeSync as closeSync10, fsyncSync as fsyncSync2, fstatSync as fstatSync10, readSync as readSync6, constants as constants8, linkSync } from "fs";
+import { existsSync as existsSync12, lstatSync as lstatSync14, statSync as statSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync13, readdirSync as readdirSync7, opendirSync as opendirSync3, readlinkSync as readlinkSync3, realpathSync as realpathSync3, renameSync as renameSync2, rmdirSync as rmdirSync2, writeFileSync as writeFileSync4, unlinkSync as unlinkSync3, chmodSync, openSync as openSync10, closeSync as closeSync10, fsyncSync as fsyncSync2, fstatSync as fstatSync10, readSync as readSync6, constants as constants8, linkSync } from "fs";
 import { dirname as dirname10, join as join20, resolve as resolve10, relative as relative4, isAbsolute as isAbsolute9, sep as sep4 } from "path";
 import { homedir as homedir3 } from "os";
 function assertSafePath(path) {
@@ -50842,7 +51056,7 @@ function readRootAlias(home, agent) {
   const stat = lstatSync14(alias, { throwIfNoEntry: false, bigint: true });
   if (!stat?.isSymbolicLink())
     throw new Error(`Agent root alias changed after planning: ${alias}`);
-  const link2 = readlinkSync2(alias), targetPath = resolve10(dirname10(alias), link2);
+  const link2 = readlinkSync3(alias), targetPath = resolve10(dirname10(alias), link2);
   assertSafePath(targetPath);
   const targetStat = lstatSync14(targetPath, { throwIfNoEntry: false });
   if (!targetStat?.isDirectory())
@@ -51042,7 +51256,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       throw new Error("Native skill discovery metadata limit exceeded");
   }
   function emptySiblingCacheAlias(path, parent) {
-    const link2 = readlinkSync2(path), target = resolve10(parent, link2);
+    const link2 = readlinkSync3(path), target = resolve10(parent, link2);
     if (dirname10(target) !== parent || (isAbsolute9(link2) ? link2 !== target : dirname10(link2) !== "."))
       return false;
     if (!lstatSync14(target, { throwIfNoEntry: false })?.isDirectory())
@@ -51071,7 +51285,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
       const marker = join20(path, ".hasna-skills.json");
       if (existsSync12(marker)) {
         try {
-          managed = JSON.parse(readFileSync12(marker, "utf8")).managedBy === "@hasna/skills";
+          managed = JSON.parse(readFileSync13(marker, "utf8")).managedBy === "@hasna/skills";
         } catch {}
       }
       const bridge = !vendor && isOwnedCliBridge(path, bridgePaths);
@@ -51144,7 +51358,7 @@ function inventoryNativeSkills(home = homedir3(), options = {}) {
 }
 function readOptional(path) {
   assertSafePath(path);
-  return existsSync12(path) ? readFileSync12(path, "utf8") : null;
+  return existsSync12(path) ? readFileSync13(path, "utf8") : null;
 }
 function jsonObject(text2, path) {
   if (text2 === null)
@@ -51945,7 +52159,7 @@ import {
   lstatSync as lstatSync15,
   mkdirSync as mkdirSync7,
   mkdtempSync,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   readdirSync as readdirSync9,
   renameSync as renameSync4,
   rmSync as rmSync2,
@@ -51962,7 +52176,7 @@ function hasSkillsOwnershipMarker(dir) {
   try {
     if (!lstatSync15(path).isFile())
       return false;
-    const marker = JSON.parse(readFileSync13(path, "utf8"));
+    const marker = JSON.parse(readFileSync14(path, "utf8"));
     return isSkillsOwnershipMarker(marker);
   } catch {
     return false;
@@ -52170,7 +52384,7 @@ function writeManagedSkillDir(dir, skillMd, options) {
   if (dirExists && managed && hasSkillMd && !options.force && isPointerSkillMd(skillMd)) {
     let existingIsStub = false;
     try {
-      existingIsStub = isPointerSkillMd(readFileSync13(skillMdPath, "utf-8"));
+      existingIsStub = isPointerSkillMd(readFileSync14(skillMdPath, "utf-8"));
     } catch {
       existingIsStub = false;
     }
@@ -52243,7 +52457,7 @@ function sourceSkillMd(skillPath, name, description, kind, preferBundledDocs = f
   if (kind === undefined || kind === "instruction" || preferBundledDocs) {
     const skillMdPath = join23(skillPath, "SKILL.md");
     if (existsSync14(skillMdPath))
-      return readFileSync13(skillMdPath, "utf-8");
+      return readFileSync14(skillMdPath, "utf-8");
   }
   return pointerSkillMd(name, description);
 }
@@ -52293,7 +52507,7 @@ var init_skill_aliases = __esm(() => {
 });
 
 // src/lib/project-state.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "fs";
 import { join as join25 } from "path";
 function getProjectStateDir(targetDir = process.cwd()) {
   return join25(targetDir, SKILLS_PROJECT_DIR);
@@ -52306,7 +52520,7 @@ function loadProjectConfig(targetDir = process.cwd()) {
   if (!existsSync15(path))
     return null;
   try {
-    return normalizeProjectConfig(JSON.parse(readFileSync14(path, "utf-8")));
+    return normalizeProjectConfig(JSON.parse(readFileSync15(path, "utf-8")));
   } catch {
     return null;
   }
@@ -52460,7 +52674,7 @@ __export(exports_installer, {
   AGENT_TARGETS: () => AGENT_TARGETS,
   AGENT_LABELS: () => AGENT_LABELS
 });
-import { existsSync as existsSync16, readFileSync as readFileSync15, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync16, rmSync as rmSync3 } from "fs";
 import { join as join26 } from "path";
 import { homedir as homedir5 } from "os";
 function getSkillPath(name) {
@@ -52559,7 +52773,7 @@ function createLocalSkillManifest(name, generateSkillMd) {
   let skillMd = "";
   const skillMdPath = join26(sourcePath, "SKILL.md");
   if (existsSync16(skillMdPath)) {
-    skillMd = readFileSync15(skillMdPath, "utf-8");
+    skillMd = readFileSync16(skillMdPath, "utf-8");
   } else if (generateSkillMd) {
     skillMd = generateSkillMd(name) ?? "";
   } else {
@@ -52686,7 +52900,7 @@ function resolveAgentSkillMd(name, generateSkillMd) {
   const sourcePath = getSkillPath(name);
   const skillMdPath = join26(sourcePath, "SKILL.md");
   if (existsSync16(skillMdPath))
-    return readFileSync15(skillMdPath, "utf-8");
+    return readFileSync16(skillMdPath, "utf-8");
   if (generateSkillMd)
     return generateSkillMd(name);
   return generateMinimalSkillMd(name);
@@ -52742,14 +52956,14 @@ function readBundledSkillVersion(name) {
   if (!existsSync16(pkgPath))
     return "unknown";
   try {
-    const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
     return pkg.version || "unknown";
   } catch {
     return "unknown";
   }
 }
 function readFileIfExists(path) {
-  return existsSync16(path) ? readFileSync15(path, "utf-8") : null;
+  return existsSync16(path) ? readFileSync16(path, "utf-8") : null;
 }
 function loadProjectConfigCompat(targetDir) {
   return loadProjectConfig(targetDir);
@@ -52824,7 +53038,7 @@ __export(exports_skillinfo, {
   generateEnvExample: () => generateEnvExample,
   detectProjectSkills: () => detectProjectSkills
 });
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
 import { join as join27 } from "path";
 function isInstructionSkillDir(skillPath, meta) {
   if (meta?.kind === "instruction")
@@ -52833,7 +53047,7 @@ function isInstructionSkillDir(skillPath, meta) {
   if (!existsSync17(skillMdPath))
     return false;
   try {
-    return parseSkillFrontmatter(readFileSync16(skillMdPath, "utf-8"))?.kind === "instruction";
+    return parseSkillFrontmatter(readFileSync17(skillMdPath, "utf-8"))?.kind === "instruction";
   } catch {
     return false;
   }
@@ -52868,7 +53082,7 @@ function getSkillRequirements(name) {
   const meta = getSkill(name);
   let dependencies = {};
   try {
-    dependencies = JSON.parse(readFileSync16(join27(skillPath, "package.json"), "utf8")).dependencies || {};
+    dependencies = JSON.parse(readFileSync17(join27(skillPath, "package.json"), "utf8")).dependencies || {};
   } catch {}
   return getSkillRequirementsFromContent(name, texts, dependencies, meta);
 }
@@ -52957,7 +53171,7 @@ async function runSkill(name, args, options = {}) {
   }
   let entryPoint2;
   try {
-    const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync17(pkgPath, "utf-8"));
     if (pkg.bin) {
       const binValues = Object.values(pkg.bin);
       entryPoint2 = binValues[0];
@@ -53002,7 +53216,7 @@ async function runSkill(name, args, options = {}) {
 function detectProjectSkills(cwd2 = process.cwd()) {
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync16(join27(cwd2, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync17(join27(cwd2, "package.json"), "utf8"));
   } catch {
     return { detected: [], recommended: [] };
   }
@@ -53088,7 +53302,7 @@ function generateSkillMd(name) {
   const pkgPath = join27(skillPath, "package.json");
   if (existsSync17(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync17(pkgPath, "utf-8"));
       if (pkg.bin) {
         const binKeys = Object.keys(pkg.bin);
         if (binKeys.length > 0)
@@ -53162,7 +53376,7 @@ function extractEnvVars(text2) {
 function readIfExists(path) {
   try {
     if (existsSync17(path)) {
-      return readFileSync16(path, "utf-8");
+      return readFileSync17(path, "utf-8");
     }
   } catch {}
   return null;
@@ -55007,7 +55221,7 @@ var init_codex_hook_discovery_recovery = __esm(() => {
 
 // src/lib/agent-discovery.ts
 import { createHash as createHash16 } from "crypto";
-import { lstatSync as lstatSync20, readFileSync as readFileSync17, readdirSync as readdirSync10, realpathSync as realpathSync4 } from "fs";
+import { lstatSync as lstatSync20, readFileSync as readFileSync18, readdirSync as readdirSync10, realpathSync as realpathSync4 } from "fs";
 import { basename as basename8, dirname as dirname16, isAbsolute as isAbsolute15, join as join31, resolve as resolve15, sep as sep5 } from "path";
 import { isDeepStrictEqual as isDeepStrictEqual7 } from "util";
 function parseConfig(text3, path, toml = false) {
@@ -55039,7 +55253,7 @@ function read2(path, changes) {
     return null;
   if (!stat2.isFile() || stat2.size > 16 * 1024 * 1024)
     throw new Error(`Unsupported or oversized native discovery input: ${path}`);
-  return readFileSync17(path, "utf8");
+  return readFileSync18(path, "utf8");
 }
 function projected(source, changes, budget = discoveryByteBudget()) {
   if (source.hashMode === "claude-settings-v1" || source.hashMode === "claude-settings-v2" || source.hashMode === "claude-settings-v3") {
@@ -56087,7 +56301,7 @@ __export(exports_registry, {
   CATEGORIES: () => CATEGORIES,
   BASIC_SKILL_NAMES: () => BASIC_SKILL_NAMES
 });
-import { existsSync as existsSync19, readFileSync as readFileSync18, readdirSync as readdirSync12 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync19, readdirSync as readdirSync12 } from "fs";
 import { join as join34 } from "path";
 function isBasicSkillName(name) {
   return BASIC_SKILL_NAMES.includes(name);
@@ -56137,7 +56351,7 @@ function discoverSkillsInDir(dir, source = "custom") {
         continue;
       let content;
       try {
-        content = readFileSync18(skillMdPath, "utf-8");
+        content = readFileSync19(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -56174,7 +56388,7 @@ function findExtensionSkillPath(name) {
         continue;
       let content;
       try {
-        content = readFileSync18(skillMdPath, "utf-8");
+        content = readFileSync19(skillMdPath, "utf-8");
       } catch {
         continue;
       }
@@ -57886,7 +58100,7 @@ var require_cli_spinners = __commonJS((exports, module) => {
 });
 
 // src/lib/auth-store.ts
-import { chmodSync as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync19, renameSync as renameSync7, statSync as statSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync20, renameSync as renameSync7, statSync as statSync11, unlinkSync as unlinkSync5, writeFileSync as writeFileSync10 } from "fs";
 import { basename as basename11, dirname as dirname19, join as join35 } from "path";
 function getAuthFilePath(env3 = process.env) {
   return skillsCredentialFilePath(env3);
@@ -57900,7 +58114,7 @@ function getAuthIdentity(env3 = process.env) {
 }
 function readIdentity(env3 = process.env) {
   try {
-    const parsed = JSON.parse(readFileSync19(getIdentityFilePath(env3), "utf-8"));
+    const parsed = JSON.parse(readFileSync20(getIdentityFilePath(env3), "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
     const record2 = parsed;
@@ -57931,7 +58145,7 @@ function writeCredentialValues(values2, env3 = process.env) {
   const lines = [];
   const written = new Set;
   if (existsSync20(file)) {
-    for (const raw of readFileSync19(file, "utf-8").split(/\r?\n/)) {
+    for (const raw of readFileSync20(file, "utf-8").split(/\r?\n/)) {
       const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(raw);
       const key = match?.[1];
       if (key && key in values2) {
@@ -57969,7 +58183,7 @@ function readCredentialValue(key, env3 = process.env) {
   if (!existsSync20(file))
     return null;
   try {
-    for (const raw of readFileSync19(file, "utf-8").split(/\r?\n/)) {
+    for (const raw of readFileSync20(file, "utf-8").split(/\r?\n/)) {
       const match = new RegExp(`^\\s*(?:export\\s+)?${key}\\s*=\\s*(.*)$`).exec(raw);
       if (!match)
         continue;
@@ -57987,7 +58201,7 @@ function readCredentialValue(key, env3 = process.env) {
 }
 function readIdentityRecord(env3 = process.env) {
   try {
-    const parsed = JSON.parse(readFileSync19(getIdentityFilePath(env3), "utf-8"));
+    const parsed = JSON.parse(readFileSync20(getIdentityFilePath(env3), "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -60276,7 +60490,7 @@ __export(exports_regexes, {
   idnEmail: () => idnEmail,
   httpProtocol: () => httpProtocol,
   html5Email: () => html5Email,
-  hostname: () => hostname,
+  hostname: () => hostname2,
   hex: () => hex,
   guid: () => guid,
   extendedDuration: () => extendedDuration,
@@ -60336,7 +60550,7 @@ var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, extendedDuration, guid, uui
 }, uuid42, uuid6, uuid7, email2, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`, ipv4, ipv6, mac = (delimiter) => {
   const escapedDelim = escapeRegex(delimiter ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
-}, cidrv4, cidrv6, base64, base64url, hostname, domain, httpProtocol, e164, creditCard, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date2, string = (params) => {
+}, cidrv4, cidrv6, base64, base64url, hostname2, domain, httpProtocol, e164, creditCard, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date2, string = (params) => {
   const regex2 = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex2}$`);
 }, bigint, integer, number, boolean, _null, _undefined, lowercase, uppercase, hex, md5_hex, md5_base64, md5_base64url, sha1_hex, sha1_base64, sha1_base64url, sha256_hex, sha256_base64, sha256_base64url, sha384_hex, sha384_base64, sha384_base64url, sha512_hex, sha512_base64, sha512_base64url;
@@ -60366,7 +60580,7 @@ var init_regexes = __esm(() => {
   cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
   base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
   base64url = /^[A-Za-z0-9_-]*$/;
-  hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+  hostname2 = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
   domain = /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
   httpProtocol = /^https?$/;
   e164 = /^\+[1-9]\d{6,14}$/;
@@ -61018,9 +61232,9 @@ function parseURLObject(trimmed, def) {
 function stripTabAndNewline(value) {
   return value.replace(asciiTabOrNewline, "");
 }
-function urlHostnameOk(url, hostname2) {
-  hostname2.lastIndex = 0;
-  return hostname2.test(url.hostname);
+function urlHostnameOk(url, hostname3) {
+  hostname3.lastIndex = 0;
+  return hostname3.test(url.hostname);
 }
 function urlProtocolOk(url, protocol) {
   protocol.lastIndex = 0;
@@ -75322,7 +75536,7 @@ __export(exports_schemas2, {
   int: () => int,
   instanceof: () => _instanceof,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash4,
   guid: () => guid2,
@@ -75524,7 +75738,7 @@ function jwt(params) {
 function stringFormat(format, fnOrRegex, _params = {}) {
   return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
 }
-function hostname2(_params) {
+function hostname3(_params) {
   return _stringFormat(ZodCustomStringFormat, "hostname", exports_regexes.hostname, _params);
 }
 function hex2(_params) {
@@ -77788,7 +78002,7 @@ __export(exports_external, {
   input: () => input,
   includes: () => _includes,
   httpUrl: () => httpUrl,
-  hostname: () => hostname2,
+  hostname: () => hostname3,
   hex: () => hex2,
   hash: () => hash4,
   guid: () => guid2,
@@ -79916,7 +80130,7 @@ var init_remote_auth = __esm(() => {
 
 // src/lib/sign-in.ts
 import { createHash as createHash19 } from "crypto";
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync12, readFileSync as readFileSync20, readdirSync as readdirSync13, renameSync as renameSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync12, readFileSync as readFileSync21, readdirSync as readdirSync13, renameSync as renameSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
 import { basename as basename12, dirname as dirname20, join as join36 } from "path";
 function isRecord6(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
@@ -80092,7 +80306,7 @@ function loadPendingDeviceSignIn(origin, env3 = process.env, now3 = Date.now())
   let parsed;
   try {
     path = pendingDeviceSignInPath(origin, env3);
-    parsed = JSON.parse(readFileSync20(path, "utf8"));
+    parsed = JSON.parse(readFileSync21(path, "utf8"));
   } catch {
     return null;
   }
@@ -80137,7 +80351,7 @@ function pendingDeviceSignInOrigins(env3 = process.env, now3 = Date.now()) {
     if (!entry.startsWith(`${location.stem}-`) || !/-[0-9a-f]{16}\.json$/.test(entry))
       continue;
     try {
-      const parsed = JSON.parse(readFileSync20(join36(location.dir, entry), "utf8"));
+      const parsed = JSON.parse(readFileSync21(join36(location.dir, entry), "utf8"));
       if (isRecord6(parsed) && typeof parsed.origin === "string" && Number(parsed.expiresAt) > now3 && pendingDeviceSignInPath(parsed.origin, env3) === join36(location.dir, entry))
         origins.push(parsed.origin);
     } catch {}
@@ -80811,7 +81025,7 @@ var init_skill_bundles = __esm(() => {
 });
 
 // src/lib/pull.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, readFileSync as readFileSync21, renameSync as renameSync9, rmSync as rmSync6, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, readFileSync as readFileSync23, renameSync as renameSync9, rmSync as rmSync6, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname21, join as join37 } from "path";
 async function pullSkills(options = {}) {
   const client2 = options.client !== undefined ? options.client : await createRemoteSkillsClient();
@@ -80973,7 +81187,7 @@ function reconcileTombstone(slug2, corpusOptions) {
 }
 function readPullMarker(dir) {
   try {
-    return JSON.parse(readFileSync21(join37(dir, PULL_MARKER_FILE), "utf-8"));
+    return JSON.parse(readFileSync23(join37(dir, PULL_MARKER_FILE), "utf-8"));
   } catch {
     return null;
   }
@@ -81475,6 +81689,24 @@ Receipt SHA256: ${result2.receiptSha256}`);
       reportContextError(error61, options.json);
     }
   });
+  sessions.command("recover-lock <id>").option("--apply", "Archive the exact reviewed stale lock", false).option("--review-digest <sha256>", "Exact digest returned by the lock review; required with --apply").option("--confirm-local-host", "Confirm this PID-only legacy lock was created on this host", false).option("--json", "Return lock metadata or recovery result as JSON", false).description("Review a stale session write lock, then archive it without changing the receipt").action(async (id, options) => {
+    try {
+      if (!options.apply) {
+        const result2 = inspectSessionWriteLock(id);
+        await writeCliOutput(options.json ? JSON.stringify(result2) : `Lock for ${JSON.stringify(id)}: PID ${result2.pid}, schema ${result2.schemaVersion}, modified ${result2.lockMtime}.
+Receipt SHA256: ${result2.receiptSha256}
+Review digest: ${result2.reviewDigest}`);
+        return;
+      }
+      if (!options.reviewDigest || !/^[a-f0-9]{64}$/.test(options.reviewDigest) || !options.confirmLocalHost) {
+        throw new SkillSelectionError("SESSION_LOCK_REVIEW_REQUIRED", "Apply requires the exact review digest and --confirm-local-host after verifying this lock belongs to this host.");
+      }
+      const archivePath = recoverSessionWriteLock(id, options.reviewDigest);
+      await writeCliOutput(options.json ? JSON.stringify({ sessionId: id, recovered: true, archivePath }) : `Archived the stale lock at ${archivePath}. The session receipt was not changed.`);
+    } catch (error61) {
+      reportContextError(error61, options.json);
+    }
+  });
   sessions.command("reconcile <id>").requiredOption("--from-profile <id>", "Expected current session profile").requiredOption("--from-revision <revision>", "Expected current session profile revision").requiredOption("--receipt-sha256 <sha256>", "Expected exact current receipt bytes").requiredOption("--selection-profile <id>", "Intended target selection profile").requiredOption("--profile-revision <revision>", "Expected current API target revision").option("--apply", "Archive the old receipt and atomically apply the reviewed plan", false).option("--plan-digest <sha256>", "Exact reviewed plan digest; required with --apply").option("--plan-issued-at <timestamp>", "Exact reviewed plan issuedAt; required with --apply").option("--plan-expires-at <timestamp>", "Exact reviewed plan expiresAt; required with --apply").option("--json", "Return the plan or application receipt as JSON", false).description("Plan an intentional migration of one session pin; ordinary hooks never migrate pins").action(async (id, options) => {
     try {
       const result2 = await reconcileSkillSession({ ...options, sessionId: id });
@@ -81592,13 +81824,13 @@ var init_context = __esm(() => {
 });
 
 // src/cli/commands/profile-sync.ts
-import { hostname as hostname3 } from "os";
+import { hostname as hostname4 } from "os";
 async function handleProfileSync(options, dependencies = {}) {
   try {
     const result2 = await syncSelectionProfile(selectedProfileId(options.selectionProfile ?? options.profile), {
       ...dependencies,
       projectDir: options.project ? process.cwd() : dependencies.projectDir,
-      stationId: options.stationReport === false ? undefined : options.station ?? dependencies.stationId ?? process.env.HASNA_STATION ?? hostname3(),
+      stationId: options.stationReport === false ? undefined : options.station ?? dependencies.stationId ?? process.env.HASNA_STATION ?? hostname4(),
       check: options.check ?? dependencies.check
     });
     if (options.json)
@@ -82326,7 +82558,7 @@ var exports_introspect = {};
 __export(exports_introspect, {
   registerIntrospect: () => registerIntrospect
 });
-import { existsSync as existsSync22, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync25 } from "fs";
 import { join as join38 } from "path";
 import { execSync } from "child_process";
 function registerIntrospect(parent) {
@@ -82548,7 +82780,7 @@ function handleDiff(name, options) {
     present: existsSync22(canonicalSkillMd),
     path: canonicalDir,
     ...existsSync22(canonicalSkillMd) ? { hash: hashSkillMarkdownFile(canonicalSkillMd) } : {},
-    ...existsSync22(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync23(canonicalSkillMd, "utf-8")) } : {}
+    ...existsSync22(canonicalSkillMd) ? { stub: isPointerSkillMd(readFileSync25(canonicalSkillMd, "utf-8")) } : {}
   };
   const pinned = getInstalledSkills().includes(bare);
   const installMeta = getInstallMeta();
@@ -82557,7 +82789,7 @@ function handleDiff(name, options) {
   let registryVersion = "unknown";
   if (existsSync22(registryPkgPath)) {
     try {
-      registryVersion = JSON.parse(readFileSync23(registryPkgPath, "utf-8")).version || "unknown";
+      registryVersion = JSON.parse(readFileSync25(registryPkgPath, "utf-8")).version || "unknown";
     } catch {}
   }
   const upToDate = installedVersion === registryVersion;
@@ -82571,7 +82803,7 @@ function handleDiff(name, options) {
     let stub;
     if (present && existsSync22(skillMdPath)) {
       try {
-        stub = isPointerSkillMd(readFileSync23(skillMdPath, "utf-8"));
+        stub = isPointerSkillMd(readFileSync25(skillMdPath, "utf-8"));
       } catch {
         stub = undefined;
       }
@@ -83109,7 +83341,7 @@ var exports_init = {};
 __export(exports_init, {
   registerSetup: () => registerSetup
 });
-import { existsSync as existsSync23, readFileSync as readFileSync25, writeFileSync as writeFileSync13, appendFileSync } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync26, writeFileSync as writeFileSync13, appendFileSync } from "fs";
 import { join as join39 } from "path";
 function registerSetup(parent) {
   parent.command("init").option("--json", "Output as JSON", false).option("--for <agent>", "Detect project type and show MCP registration guidance for agent").option("--scope <scope>", "Deprecated; agent skill-folder installs are disabled", "global").description("Initialize project for pinned skills (.env.example, .gitignore)").action((options) => handleInit(options));
@@ -83204,7 +83436,7 @@ Use: skills render`));
     console.log(source_default.dim("  No environment variables detected across pinned skills"));
   const gitignorePath = join39(cwd2, ".gitignore");
   const gitignoreEntries = [".skills/runs/", ".skills/exports/", ".skills/tmp/"];
-  let gitignoreContent = existsSync23(gitignorePath) ? readFileSync25(gitignorePath, "utf-8") : "";
+  let gitignoreContent = existsSync23(gitignorePath) ? readFileSync26(gitignorePath, "utf-8") : "";
   let gitignoreUpdated = false;
   const missingEntries = gitignoreEntries.filter((entry) => !gitignoreContent.includes(entry));
   if (missingEntries.length > 0) {
@@ -83259,7 +83491,7 @@ async function handleImport(file2, options) {
         process.exitCode = 1;
         return;
       }
-      raw = readFileSync25(file2, "utf-8");
+      raw = readFileSync26(file2, "utf-8");
     }
   } catch (err) {
     const error61 = `Failed to read file: ${err.message}`;
@@ -83356,7 +83588,7 @@ var init_init = __esm(() => {
 });
 
 // src/lib/home-adoption.ts
-import { constants as constants13, closeSync as closeSync15, fstatSync as fstatSync15, lstatSync as lstatSync22, openSync as openSync15, readSync as readSync12, existsSync as existsSync24, mkdirSync as mkdirSync14, readdirSync as readdirSync14, readFileSync as readFileSync26, rmSync as rmSync7, statSync as statSync12, writeFileSync as writeFileSync14 } from "fs";
+import { constants as constants13, closeSync as closeSync15, fstatSync as fstatSync15, lstatSync as lstatSync22, openSync as openSync15, readSync as readSync12, existsSync as existsSync24, mkdirSync as mkdirSync14, readdirSync as readdirSync14, readFileSync as readFileSync27, rmSync as rmSync7, statSync as statSync12, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join40 } from "path";
 function indexCanonicalCorpus(corpusRoot) {
@@ -83460,7 +83692,7 @@ function appendConflictsLedger(appDir, conflicts) {
   let ledger = { version: 1, entries: [] };
   if (existsSync24(ledgerPath)) {
     try {
-      const parsed = JSON.parse(readFileSync26(ledgerPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync27(ledgerPath, "utf-8"));
       if (parsed && typeof parsed === "object" && Array.isArray(parsed.entries)) {
         ledger = parsed;
       }
@@ -83609,7 +83841,7 @@ var init_home_adoption = __esm(() => {
 });
 
 // src/lib/home-census.ts
-import { existsSync as existsSync25, readFileSync as readFileSync27, readdirSync as readdirSync15, statSync as statSync13 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync28, readdirSync as readdirSync15, statSync as statSync13 } from "fs";
 import { homedir as homedir9 } from "os";
 import { join as join41 } from "path";
 function sortEntries(entries) {
@@ -83680,14 +83912,14 @@ function censusHomeDrift(options = {}) {
       if (homeHash !== canonicalHash) {
         let homeStub;
         try {
-          homeStub = isPointerSkillMd(readFileSync27(skillMdPath, "utf-8"));
+          homeStub = isPointerSkillMd(readFileSync28(skillMdPath, "utf-8"));
         } catch {
           homeStub = undefined;
         }
         let canonicalStub;
         const canonicalSkillMd = join41(corpusRoot, skill, "SKILL.md");
         try {
-          canonicalStub = isPointerSkillMd(readFileSync27(canonicalSkillMd, "utf-8"));
+          canonicalStub = isPointerSkillMd(readFileSync28(canonicalSkillMd, "utf-8"));
         } catch {
           canonicalStub = undefined;
         }
@@ -83725,7 +83957,7 @@ var init_home_census = __esm(() => {
 });
 
 // src/cli/env-assignment.ts
-import { closeSync as closeSync16, constants as constants14, fstatSync as fstatSync16, ftruncateSync as ftruncateSync2, lstatSync as lstatSync23, openSync as openSync16, readFileSync as readFileSync28, writeSync as writeSync3 } from "fs";
+import { closeSync as closeSync16, constants as constants14, fstatSync as fstatSync16, ftruncateSync as ftruncateSync2, lstatSync as lstatSync23, openSync as openSync16, readFileSync as readFileSync29, writeSync as writeSync3 } from "fs";
 function serializeValue(value) {
   if (controls.test(value))
     throw new EnvAssignmentError("Environment values cannot contain control characters or newlines.");
@@ -83820,7 +84052,7 @@ function setEnvAssignment(path, assignment) {
     }
     let prepared = initial2;
     if (previous) {
-      const original = readFileSync28(descriptor), text4 = original.toString("utf8");
+      const original = readFileSync29(descriptor), text4 = original.toString("utf8");
       if (!Buffer.from(text4, "utf8").equals(original))
         throw new EnvAssignmentError(INVALID_LAYOUT);
       prepared = prepareEnvAssignment(assignment, text4);
@@ -83907,7 +84139,7 @@ var exports_diagnostic = {};
 __export(exports_diagnostic, {
   registerDiagnostic: () => registerDiagnostic
 });
-import { existsSync as existsSync26, readFileSync as readFileSync29, readdirSync as readdirSync16, statSync as statSync14 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync30, readdirSync as readdirSync16, statSync as statSync14 } from "fs";
 import { join as join42 } from "path";
 import { execSync as execSync2 } from "child_process";
 function registerDiagnostic(parent) {
@@ -84148,7 +84380,7 @@ function handleOutdated(options) {
     let registryVersion = "unknown";
     if (existsSync26(registryPkgPath))
       try {
-        registryVersion = JSON.parse(readFileSync29(registryPkgPath, "utf-8")).version || "unknown";
+        registryVersion = JSON.parse(readFileSync30(registryPkgPath, "utf-8")).version || "unknown";
       } catch {}
     if (installedVersion !== registryVersion)
       pins.push({ skill: name, installedVersion, registryVersion });
@@ -84358,8 +84590,8 @@ var init_cloud_executions = __esm(() => {
 
 // node_modules/@hasna/secrets/dist/sdk.js
 import { isIP as isIP3 } from "net";
-import { spawnSync as spawnSync2 } from "child_process";
-import { closeSync as closeSync17, fstatSync as fstatSync17, openSync as openSync17, readFileSync as readFileSync30 } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { closeSync as closeSync17, fstatSync as fstatSync17, openSync as openSync17, readFileSync as readFileSync31 } from "fs";
 import { O_NOFOLLOW as O_NOFOLLOW3, O_NONBLOCK as O_NONBLOCK3, O_RDONLY as O_RDONLY3 } from "constants";
 import { createRequire as createRequire2 } from "module";
 import { hostname as osHostname2 } from "os";
@@ -84485,7 +84717,7 @@ function readAppConfigFile2(path) {
       unsafe("the file is not owned by the current user");
     if (before2.size > MAX_CREDENTIAL_FILE_BYTES2)
       unsafe("the file exceeds the size limit");
-    const bytes = readFileSync30(fd);
+    const bytes = readFileSync31(fd);
     const after2 = fstatSync17(fd);
     if (!configFileReadsCoherent2(before2, after2)) {
       unsafe("the file changed while being read");
@@ -84633,7 +84865,7 @@ function isAmbientEnvironment2(env3) {
   return env3 === process.env || env3[AMBIENT_ENVIRONMENT2] === true;
 }
 function defaultKeychainRunner2(argv) {
-  const result2 = spawnSync2(KEYCHAIN_SECURITY_BIN2, [...argv], {
+  const result2 = spawnSync3(KEYCHAIN_SECURITY_BIN2, [...argv], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: KEYCHAIN_SPAWN_TIMEOUT_MS2
@@ -90352,7 +90584,7 @@ var init_runs = __esm(() => {
 
 // src/lib/run-state.ts
 import { createHash as createHash24, randomBytes } from "crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync31, readdirSync as readdirSync17, statSync as statSync15, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readFileSync as readFileSync32, readdirSync as readdirSync17, statSync as statSync15, writeFileSync as writeFileSync16 } from "fs";
 import { extname, join as join45, relative as relative6 } from "path";
 function createSkillRun(params, targetDir = process.cwd()) {
   const now3 = new Date;
@@ -90424,7 +90656,7 @@ function appendRunEvent(context, event, data = {}) {
   const line = JSON.stringify({ ts: new Date().toISOString(), event, ...data }) + `
 `;
   const path = join45(context.runDir, "events.ndjson");
-  const previous = existsSync27(path) ? readFileSync31(path, "utf-8") : "";
+  const previous = existsSync27(path) ? readFileSync32(path, "utf-8") : "";
   writeFileSync16(path, previous + line);
 }
 function listSkillRuns(targetDir = process.cwd(), limit = 50) {
@@ -90484,7 +90716,7 @@ function collectRunArtifacts(context) {
   const artifacts = [];
   for (const path of walkFiles(context.exportDir)) {
     const stat2 = statSync15(path);
-    const bytes = readFileSync31(path);
+    const bytes = readFileSync32(path);
     artifacts.push({
       path: toProjectRelative(context.targetDir, path),
       mime: mimeForPath(path),
@@ -90499,7 +90731,7 @@ function readRunRecord(runDir) {
   if (!existsSync27(path))
     return null;
   try {
-    return JSON.parse(readFileSync31(path, "utf-8"));
+    return JSON.parse(readFileSync32(path, "utf-8"));
   } catch {
     return null;
   }
@@ -102524,7 +102756,7 @@ var init_remote_customer_operations = __esm(() => {
 });
 
 // src/lib/workspace-profile.ts
-import { constants as constants16, closeSync as closeSync19, fstatSync as fstatSync19, lstatSync as lstatSync24, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync5, openSync as openSync19, readFileSync as readFileSync32, renameSync as renameSync10, rmSync as rmSync8, writeFileSync as writeFileSync17 } from "fs";
+import { constants as constants16, closeSync as closeSync19, fstatSync as fstatSync19, lstatSync as lstatSync24, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync5, openSync as openSync19, readFileSync as readFileSync33, renameSync as renameSync10, rmSync as rmSync8, writeFileSync as writeFileSync17 } from "fs";
 import { dirname as dirname23, join as join46 } from "path";
 function stat2(path) {
   try {
@@ -102543,7 +102775,7 @@ function safeText(file2) {
     const s = fstatSync19(fd);
     if (!s.isFile() || s.size > 65536 || ![256, 384].includes(s.mode & 4095) || process.getuid && s.uid !== process.getuid())
       return fail3("The selected profile must use bounded owner-only regular files.");
-    return readFileSync32(fd, "utf8");
+    return readFileSync33(fd, "utf8");
   } finally {
     closeSync19(fd);
   }
@@ -105421,7 +105653,7 @@ var init_resource_meta_tools = __esm(() => {
 });
 
 // src/lib/scheduler.ts
-import { existsSync as existsSync30, readFileSync as readFileSync33, writeFileSync as writeFileSync19, mkdirSync as mkdirSync20 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync34, writeFileSync as writeFileSync19, mkdirSync as mkdirSync20 } from "fs";
 import { join as join50 } from "path";
 function getSchedulesPath(targetDir = process.cwd()) {
   return join50(targetDir, ".skills", "schedules.json");
@@ -105430,7 +105662,7 @@ function loadSchedules(targetDir = process.cwd()) {
   const path = getSchedulesPath(targetDir);
   if (existsSync30(path)) {
     try {
-      return JSON.parse(readFileSync33(path, "utf-8"));
+      return JSON.parse(readFileSync34(path, "utf-8"));
     } catch {}
   }
   return { version: 1, schedules: [] };
@@ -105740,7 +105972,7 @@ import { createHash as createHash25, createHmac as createHmac3 } from "crypto";
 import {
   existsSync as existsSync31,
   mkdirSync as mkdirSync21,
-  readFileSync as readFileSync34,
+  readFileSync as readFileSync35,
   readdirSync as readdirSync19,
   statSync as statSync17,
   writeFileSync as writeFileSync20
@@ -105808,7 +106040,7 @@ function exportSkillsLocalSnapshot(targetDir = process.cwd(), options = {}) {
   const files = [];
   if (existsSync31(projectStateDir)) {
     for (const filePath of walkFiles2(projectStateDir)) {
-      const bytes = readFileSync34(filePath);
+      const bytes = readFileSync35(filePath);
       const relativePath = toPosix(relative7(targetDir, filePath));
       files.push({
         path: relativePath,
@@ -106713,7 +106945,7 @@ var exports_runtime_mcp = {};
 __export(exports_runtime_mcp, {
   handleMcp: () => handleMcp
 });
-import { existsSync as existsSync32, mkdirSync as mkdirSync23, readFileSync as readFileSync35, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync23, readFileSync as readFileSync36, writeFileSync as writeFileSync22 } from "fs";
 import { homedir as homedir10 } from "os";
 import { dirname as dirname28, join as join53 } from "path";
 async function handleMcp(options) {
@@ -106824,7 +107056,7 @@ function registerCodexMcp(command) {
   const config2 = `[mcp_servers.${MCP_SERVER_NAME}]
 command = ${JSON.stringify(command)}`;
   try {
-    const current = existsSync32(path) ? readFileSync35(path, "utf-8") : "";
+    const current = existsSync32(path) ? readFileSync36(path, "utf-8") : "";
     writeTextFile(path, upsertTomlSection(current, `[mcp_servers.${MCP_SERVER_NAME}]`, `command = ${JSON.stringify(command)}`));
     return { agent: "codex", success: true, path, config: config2 };
   } catch (err) {
@@ -106876,7 +107108,7 @@ function registerJsonMcpServer(agent, path, containerKey, server2) {
 function readJsonObject2(path) {
   if (!existsSync32(path))
     return {};
-  const raw = readFileSync35(path, "utf-8").trim();
+  const raw = readFileSync36(path, "utf-8").trim();
   if (!raw)
     return {};
   const parsed = JSON.parse(raw);
@@ -107000,7 +107232,7 @@ __export(exports_runtime, {
   registerRuntime: () => registerRuntime
 });
 import { createHash as createHash26, randomUUID as randomUUID9 } from "crypto";
-import { lstatSync as lstatSync27, mkdirSync as mkdirSync24, readFileSync as readFileSync36, realpathSync as realpathSync11, writeFileSync as writeFileSync23 } from "fs";
+import { lstatSync as lstatSync27, mkdirSync as mkdirSync24, readFileSync as readFileSync37, realpathSync as realpathSync11, writeFileSync as writeFileSync23 } from "fs";
 import { basename as basename13, isAbsolute as isAbsolute22, join as join54 } from "path";
 import { createInterface } from "readline";
 function registerRuntime(parent) {
@@ -107453,7 +107685,7 @@ async function handleRun(name, args2, options, separatorBeforeSkill) {
         const info = lstatSync27(path);
         if (!info.isFile() || info.size > 20 * 1024 * 1024)
           throw new Error("Input must be a regular file no larger than 20 MiB");
-        return { name: basename13(path), bytes: new Uint8Array(readFileSync36(path)) };
+        return { name: basename13(path), bytes: new Uint8Array(readFileSync37(path)) };
       });
       describeRemoteFiles(inputFiles);
       client2 = new RemoteSkillsClient(routing.apiKey, routing.apiOrigin);
@@ -108625,7 +108857,7 @@ import { createHash as createHash27 } from "crypto";
 import {
   copyFileSync,
   mkdirSync as mkdirSync25,
-  readFileSync as readFileSync37,
+  readFileSync as readFileSync38,
   statSync as statSync19,
   writeFileSync as writeFileSync24
 } from "fs";
@@ -108636,7 +108868,7 @@ function validateStationId(stationId) {
   }
 }
 function sha256File(filePath) {
-  return createHash27("sha256").update(readFileSync37(filePath)).digest("hex");
+  return createHash27("sha256").update(readFileSync38(filePath)).digest("hex");
 }
 function scanHome(definition, homesRoot) {
   const homePath = homePathFor(definition, homesRoot);
@@ -109465,7 +109697,7 @@ var init_codex_hook_policy_recovery = __esm(() => {
 });
 
 // src/lib/agent-codex-trust.ts
-import { lstatSync as lstatSync29, mkdirSync as mkdirSync26, readdirSync as readdirSync21, readFileSync as readFileSync38, realpathSync as realpathSync14, statSync as statSync21 } from "fs";
+import { lstatSync as lstatSync29, mkdirSync as mkdirSync26, readdirSync as readdirSync21, readFileSync as readFileSync39, realpathSync as realpathSync14, statSync as statSync21 } from "fs";
 import { createHash as createHash28, randomUUID as randomUUID10 } from "crypto";
 import { execFileSync } from "child_process";
 import { dirname as dirname32, isAbsolute as isAbsolute26, join as join58, resolve as resolve23 } from "path";
@@ -109475,13 +109707,13 @@ function verifyReleaseArtifact(proof, skillsCli) {
   need4(isAbsolute26(proof.packageTarPath) && !proof.packageTarPath.includes("\x00"), "RECONCILE_RELEASE_PROVENANCE_PATH");
   const tarPath = realpathSync14(proof.packageTarPath);
   need4(statSync21(tarPath).isFile(), "RECONCILE_RELEASE_PROVENANCE_PATH");
-  const tarBytes = readFileSync38(tarPath);
+  const tarBytes = readFileSync39(tarPath);
   need4(tarBytes.byteLength === proof.packageTarBytes && createHash28("sha256").update(tarBytes).digest("hex") === proof.packageTarSha256, "RECONCILE_RELEASE_ARTIFACT_CHANGED");
   const packageRoot = dirname32(dirname32(realpathSync14(skillsCli.receipt.path)));
-  const manifest = readFileSync38(join58(packageRoot, "package.json"));
+  const manifest = readFileSync39(join58(packageRoot, "package.json"));
   need4(createHash28("sha256").update(manifest).digest("hex") === skillsCli.receipt.manifestSha256 && skillsCli.receipt.manifestSha256 === proof.manifestSha256, "RECONCILE_RELEASE_MANIFEST_CHANGED");
-  need4(createHash28("sha256").update(readFileSync38(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
-  const members2 = [["package/package.json", manifest], ["package/bin/index.js", readFileSync38(skillsCli.receipt.path)]];
+  need4(createHash28("sha256").update(readFileSync39(skillsCli.receipt.path)).digest("hex") === proof.executableSha256 && skillsCli.receipt.sha256 === proof.executableSha256, "RECONCILE_RELEASE_EXECUTABLE_CHANGED");
+  const members2 = [["package/package.json", manifest], ["package/bin/index.js", readFileSync39(skillsCli.receipt.path)]];
   for (const [member, expected] of members2) {
     let actual;
     try {
@@ -109882,7 +110114,8 @@ var init_hook_diagnostics = __esm(() => {
     "SESSION_RECEIPT_CHANGED",
     "SESSION_RECONCILIATION_INCOMPLETE",
     "SESSION_WRITE_LOCKED",
-    "SESSION_WRITE_LOCK_CHANGED"
+    "SESSION_WRITE_LOCK_CHANGED",
+    "SESSION_LOCK_RECOVERY_INCOMPLETE"
   ]);
   HookDiagnosticError = class HookDiagnosticError extends Error {
     code;
@@ -109900,7 +110133,7 @@ var exports_agent_integration = {};
 __export(exports_agent_integration, {
   registerAgentIntegration: () => registerAgentIntegration
 });
-import { readFileSync as readFileSync39 } from "fs";
+import { readFileSync as readFileSync40 } from "fs";
 import { isAbsolute as isAbsolute27 } from "path";
 function pinnedHookProfile(input3, configuredProfile) {
   try {
@@ -109978,7 +110211,7 @@ function registerAgentIntegration(parent) {
   });
   hook.command("install").option("--agent <agent>", `Agent to configure: ${INTEGRATION_AGENTS.join(", ")}, all`, "all").option("--command <path>", "Skills executable used by the hook (preserves existing binding; new agents use skills)").option("--selection-profile <id>", "Selection profile (preserves existing binding; new agents use default)").option("--include-vendor", "Retained for compatibility; vendor system skills are always inventoried and disabled", false).option("--discovery-inputs <file>", "Advanced reviewed active plugin roots and source hashes for unsupported registrations").option("--allow-root-aliases", "Allow home .claude/.codex aliases to existing directories within this home", false).option("--apply", "Apply the plan, preserving prior configuration in private backups", false).option("--json", "Output a receipt as JSON", false).description("Plan or install one Skills CLI bridge plus native prompt hooks").action(async (options) => {
     try {
-      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync39(options.discoveryInputs, "utf8")) : undefined;
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync40(options.discoveryInputs, "utf8")) : undefined;
       const plan = planAgentIntegration({ agents: agents(options.agent), command: options.command, profileId: options.selectionProfile, includeVendor: options.includeVendor, discoveryInputs, allowRootAliases: options.allowRootAliases });
       const result2 = options.apply ? applyAgentIntegration(plan) : { changed: [], backups: [] };
       const receipt = { applied: options.apply, planned: plan.changes.map((change) => change.path), ...result2, rootAliases: plan.rootAliases ?? [], discovery: plan.discoveryAfter, nativeSkills: plan.nativeSkills.map((entry) => ({ agent: entry.agent, path: entry.path, managed: entry.managed, vendor: entry.vendor, system: entry.system === true, bridge: entry.bridge === true })), requiresNativeRetirement: plan.nativeSkills.some((entry) => !entry.bridge && !entry.system) };
@@ -110036,7 +110269,7 @@ function registerAgentIntegration(parent) {
     try {
       if (agents(options.agent).length !== 1)
         throw new Error("A hook invocation requires one agent");
-      const inputText = readFileSync39(0, "utf8");
+      const inputText = readFileSync40(0, "utf8");
       if (inputText.length > 1024 * 1024)
         throw new Error("Hook input is too large");
       let input3 = JSON.parse(inputText);
@@ -110132,7 +110365,7 @@ function registerAgentIntegration(parent) {
   const migrate = parent.command("migrate").description("Preserve and retire native agent skill copies");
   migrate.command("native").option("--project <directory>", "Also inventory a project and its ancestors (the current directory and its ancestors are always included)").option("--include-unmanaged", "Archive user-authored skills as well as Skills-managed copies", false).option("--include-vendor", "Retire vendor SKILL.md discovery files while preserving plugin scripts and assets", false).option("--target-manifest <file>", "Reviewed exact native migration target manifest").option("--discovery-inputs <file>", "Advanced reviewed active plugin roots and source hashes").option("--allow-root-aliases", "Allow home .claude/.codex aliases to existing directories within this home", false).option("--apply", "Move selected skills to private archives outside agent discovery roots", false).option("--json", "Output inventory and archive receipt as JSON", false).description("Inventory native skill copies; preserve complete directories before retiring them").action(async (options) => {
     try {
-      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync39(options.discoveryInputs, "utf8")) : undefined;
+      const discoveryInputs = options.discoveryInputs ? JSON.parse(readFileSync40(options.discoveryInputs, "utf8")) : undefined;
       if (options.targetManifest && (options.includeUnmanaged || options.includeVendor))
         throw new Error("--target-manifest cannot be combined with broad native migration selectors");
       const targetManifest = options.targetManifest ? readNativeMigrationTargetManifest(options.targetManifest) : undefined;
@@ -110439,7 +110672,7 @@ import {
   copyFileSync as copyFileSync2,
   mkdirSync as mkdirSync27,
   readdirSync as readdirSync22,
-  readFileSync as readFileSync40,
+  readFileSync as readFileSync41,
   statSync as statSync22,
   writeFileSync as writeFileSync27
 } from "fs";
@@ -110455,7 +110688,7 @@ function readSnapshotManifest(repoRoot, stationId) {
   const manifestPath = join59(snapshotRoot, "sync-manifest.json");
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync40(manifestPath, "utf8"));
+    manifest = JSON.parse(readFileSync41(manifestPath, "utf8"));
   } catch (error61) {
     fail5("MANIFEST_UNREADABLE", `cannot read snapshot manifest: ${manifestPath}: ${error61.message}`);
   }
@@ -110591,7 +110824,7 @@ function planStationHydration(stationId, repoRoot) {
         for (const copy of copies) {
           let isStub = false;
           try {
-            isStub = isPointerSkillMd(readFileSync40(copy.fullPath, "utf8"));
+            isStub = isPointerSkillMd(readFileSync41(copy.fullPath, "utf8"));
           } catch {
             isStub = false;
           }
@@ -110795,7 +111028,7 @@ var init_hydrate = __esm(() => {
 
 // src/lib/prepare-skill.ts
 import { createHash as createHash30, randomUUID as randomUUID11 } from "crypto";
-import { chmodSync as chmodSync4, existsSync as existsSync34, lstatSync as lstatSync30, mkdirSync as mkdirSync28, mkdtempSync as mkdtempSync6, readFileSync as readFileSync41, readdirSync as readdirSync23, renameSync as renameSync13, rmSync as rmSync9, writeFileSync as writeFileSync28 } from "fs";
+import { chmodSync as chmodSync4, existsSync as existsSync34, lstatSync as lstatSync30, mkdirSync as mkdirSync28, mkdtempSync as mkdtempSync6, readFileSync as readFileSync42, readdirSync as readdirSync23, renameSync as renameSync13, rmSync as rmSync9, writeFileSync as writeFileSync28 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname34, isAbsolute as isAbsolute28, join as join60, relative as relative9, resolve as resolve25, sep as sep12 } from "path";
 function prepareSkill(name, options) {
@@ -111015,7 +111248,7 @@ function snapshot2(root2) {
         bytes += stat3.size;
         if (bytes > 50000000)
           throw new Error("Skill exceeds the preparation size limit (50000000 bytes).");
-        const content = readFileSync41(absolute);
+        const content = readFileSync42(absolute);
         if (content.length !== stat3.size)
           throw new Error("Skill changed during preparation.");
         files.push({ path, bytes: content, mode: stat3.mode & 511 });
@@ -111697,8 +111930,8 @@ __export(exports_publish, {
   PushSkillError: () => PushSkillError
 });
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync35, readFileSync as readFileSync42 } from "fs";
-import { hostname as hostname4 } from "os";
+import { existsSync as existsSync35, readFileSync as readFileSync43 } from "fs";
+import { hostname as hostname5 } from "os";
 import { join as join61 } from "path";
 function registerPublish(parent) {
   parent.command("push").argument("<name>", "Name of a skill in the local corpus (~/.hasna/skills/installed or the migrated ~/.hasna/skills/skills)").option("--version <version>", "Override the version recorded on the instance").option("--force-new-version", "If name@version already exists with different content, publish as the next patch version", false).option("--dry-run", "Pack and validate without uploading", false).option("--json", "Output result as JSON", false).description("Publish a local skill to the configured skills instance").action(async (name, options) => {
@@ -111752,7 +111985,7 @@ async function pushSkill(name, options = {}) {
   await verifyPackedCanonicalHash(skill.name, packed);
   const versionManifest = buildVersionManifest(skill.path, packed);
   const skillMdPath = join61(skill.path, "SKILL.md");
-  const skillMd = existsSync35(skillMdPath) ? readFileSync42(skillMdPath, "utf-8") : undefined;
+  const skillMd = existsSync35(skillMdPath) ? readFileSync43(skillMdPath, "utf-8") : undefined;
   const base3 = {
     slug: skill.name,
     path: skill.path,
@@ -111882,7 +112115,7 @@ function buildVersionManifest(skillDir, packed) {
     unpackedByteSize: packed.unpackedByteSize,
     bundleSha256: packed.sha256,
     provenance: {
-      machine: hostname4(),
+      machine: hostname5(),
       agent: process.env.SKILLS_AGENT_ID ?? process.env.HASNA_AGENT_ID ?? process.env.AGENT_ID ?? null,
       cliVersion: package_default.version,
       gitRemote: sanitizeGitRemote(gitValue(skillDir, ["remote", "get-url", "origin"])),
@@ -113471,7 +113704,7 @@ var init_storage2 = __esm(() => {
 });
 
 // src/lib/registry-reconcile.ts
-import { existsSync as existsSync36, readFileSync as readFileSync43, statSync as statSync23, writeFileSync as writeFileSync30 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync44, statSync as statSync23, writeFileSync as writeFileSync30 } from "fs";
 import { join as join62 } from "path";
 function isDirectory2(path) {
   try {
@@ -113491,7 +113724,7 @@ function readBaseline(skillDir) {
   if (!existsSync36(markerPath))
     return;
   try {
-    const marker = JSON.parse(readFileSync43(markerPath, "utf-8"));
+    const marker = JSON.parse(readFileSync44(markerPath, "utf-8"));
     if (!isSkillsOwnershipMarker(marker))
       return;
     return {
@@ -113507,7 +113740,7 @@ function readCursor(root2) {
   if (!existsSync36(path))
     return { runCount: 0 };
   try {
-    const cursor2 = JSON.parse(readFileSync43(path, "utf-8"));
+    const cursor2 = JSON.parse(readFileSync44(path, "utf-8"));
     return { runCount: typeof cursor2.runCount === "number" ? cursor2.runCount : 0 };
   } catch {
     return { runCount: 0 };