litgrok-ai 0.2.4 → 0.2.6

package/.grok/skills/autoconference/references/_canonical-corpus/manifest.json

@@ -6,8 +6,8 @@
     "selection": "25 companion files retained; SKILL.md is a Grok-native adapter"
   },
   "file_count": 25,
-  "byte_count": 54924,
-  "aggregate_sha256": "13060670bae942a618c1c905243ca6cda158f153fab25ffa6e46d55a42778170",
+  "byte_count": 55711,
+  "aggregate_sha256": "406a7ca96354e3b863577cdbcb783122031fd451f967d0a2bfadfcdd1949fd34",
   "files": [
     {
       "path": "assets/conference_template.md",
@@ -101,8 +101,8 @@
     },
     {
       "path": "scripts/init_conference.py",
-      "size": 21078,
-      "sha256": "cb83623c1338b7e3a5be7a7beac7a17b8ae362fc24fbc01d1caff634db290dfc"
+      "size": 21865,
+      "sha256": "58aaaa91d3f31bdacfccac4c3a736efb62cb89563f7d37281be0e49f84651187"
     },
     {
       "path": "templates/code-performance.md",

package/.grok/skills/autoconference/scripts/init_conference.py

@@ -209,6 +209,23 @@ def preflight_capabilities() -> None:
         )
 
 
+def same_directory_identity(left: os.stat_result, right: os.stat_result) -> bool:
+    """Compare path identity, including ctime to reject recreated directories."""
+    return (
+        left.st_dev,
+        left.st_ino,
+        left.st_mode,
+        left.st_uid,
+        left.st_ctime_ns,
+    ) == (
+        right.st_dev,
+        right.st_ino,
+        right.st_mode,
+        right.st_uid,
+        right.st_ctime_ns,
+    )
+
+
 def open_safe_directory(path: Path) -> Tuple[int, Path]:
     """Create/open path one component at a time without following symlinks."""
     absolute = Path(os.path.abspath(os.fspath(path)))
@@ -233,7 +250,16 @@ def open_safe_directory(path: Path) -> Tuple[int, Path]:
                 fail("UNSAFE_OUTPUT_SYMLINK", f"output component is a symlink: {absolute}")
             if not stat.S_ISDIR(info.st_mode):
                 fail("UNSAFE_OUTPUT_PATH", f"output component is not a directory: {absolute}")
-            next_fd = os.open(part, flags | nofollow, dir_fd=fd)
+            next_fd = None
+            try:
+                next_fd = os.open(part, flags | nofollow, dir_fd=fd)
+                opened = os.fstat(next_fd)
+                if not same_directory_identity(info, opened):
+                    fail("UNSAFE_OUTPUT_SWAP", f"output component identity changed: {absolute}")
+            except BaseException:
+                if next_fd is not None:
+                    os.close(next_fd)
+                raise
             os.close(fd)
             fd = next_fd
         verify_directory_identity(absolute, fd)
@@ -251,7 +277,7 @@ def verify_directory_identity(path: Path, fd: int) -> None:
     opened = os.fstat(fd)
     if stat.S_ISLNK(named.st_mode) or not stat.S_ISDIR(named.st_mode):
         fail("UNSAFE_OUTPUT_SYMLINK", f"output directory is no longer a real directory: {path}")
-    if (named.st_dev, named.st_ino) != (opened.st_dev, opened.st_ino):
+    if not same_directory_identity(named, opened):
         fail("UNSAFE_OUTPUT_SWAP", f"output directory identity changed: {path}")
 
 

package/.grok/skills/autoconference/scripts/verify-canonical-corpus.mjs

@@ -11,8 +11,8 @@ const VERIFIER_RELATIVE = 'scripts/verify-canonical-corpus.mjs';
 const EXPECTED = Object.freeze({
   "schemaVersion": "litgrok.autoconference-corpus/v1",
   "fileCount": 25,
-  "byteCount": 54924,
-  "aggregateSha256": "13060670bae942a618c1c905243ca6cda158f153fab25ffa6e46d55a42778170",
+  "byteCount": 55711,
+  "aggregateSha256": "406a7ca96354e3b863577cdbcb783122031fd451f967d0a2bfadfcdd1949fd34",
   "files": {
     "assets/conference_template.md": "c1b0a1bbfb52080384e9bf6d725a91d2165a2105a4f055820660a607c913c7e7",
     "assets/report_template.md": "73a00032dc143f34f67a97a257f76e7a5acd9365d367e0b27d0c72e439a336ab",
@@ -32,7 +32,7 @@ const EXPECTED = Object.freeze({
     "references/modes/survey.md": "93866084c2abe5d7a1c6ef7251e5594e03044545ddda5e80c1ca42ef450769d0",
     "references/results-logging.md": "829714f30af623aa78a4ebc9e13a0ba7135b2c876af3443e1c1274af8857fe96",
     "references/visualization-guide.md": "4f7e705735b948038193c5a9c111e2db85672f5d97bb1c570aad217843868331",
-    "scripts/init_conference.py": "cb83623c1338b7e3a5be7a7beac7a17b8ae362fc24fbc01d1caff634db290dfc",
+    "scripts/init_conference.py": "58aaaa91d3f31bdacfccac4c3a736efb62cb89563f7d37281be0e49f84651187",
     "templates/code-performance.md": "a90d1425477d9aec002778ba695299cfabb593ccd3dbab82ed0d76038e17a4d5",
     "templates/debate-mode.md": "9c74435dc7eb2e2d24d32b0a80381aadc62890f4674d916022ce6ef220aab966",
     "templates/prompt-optimization.md": "8d78c233529533bb742986769941347eebc460fdb2a2dac63952e65883398e10",

package/.grok/skills/autoresearch/references/_canonical-corpus/manifest.json

@@ -6,8 +6,8 @@
     "selection": "27 companion files retained; SKILL.md is a Grok-native adapter"
   },
   "file_count": 27,
-  "byte_count": 38018,
-  "aggregate_sha256": "520a3c79715f484e912439dd0b350b652e30e3e78c8eb278061bfc90174e124c",
+  "byte_count": 38805,
+  "aggregate_sha256": "0296ca6e52fb7cb68a37f3e17f148248146955ad9624e37e449e60b56eeeb1d3",
   "files": [
     {
       "path": "assets/report_template.md",
@@ -136,8 +136,8 @@
     },
     {
       "path": "scripts/init_research.py",
-      "size": 13374,
-      "sha256": "a5434711928eb4d0487d933df5e1b374f8553140004c6ab8e38fe577ae074d05"
+      "size": 14161,
+      "sha256": "b675ea22abf0794e32dbbf59b95248f20878bbf3d071fa10d37b5a004a7f880c"
     },
     {
       "path": "scripts/style_presets.py",

package/.grok/skills/autoresearch/scripts/init_research.py

@@ -103,6 +103,23 @@ def preflight_capabilities() -> None:
         )
 
 
+def same_directory_identity(left: os.stat_result, right: os.stat_result) -> bool:
+    """Compare path identity, including ctime to reject recreated directories."""
+    return (
+        left.st_dev,
+        left.st_ino,
+        left.st_mode,
+        left.st_uid,
+        left.st_ctime_ns,
+    ) == (
+        right.st_dev,
+        right.st_ino,
+        right.st_mode,
+        right.st_uid,
+        right.st_ctime_ns,
+    )
+
+
 def open_safe_directory(path: Path) -> Tuple[int, Path]:
     """Create/open path one component at a time without following symlinks."""
     absolute = Path(os.path.abspath(os.fspath(path)))
@@ -127,7 +144,16 @@ def open_safe_directory(path: Path) -> Tuple[int, Path]:
                 fail("UNSAFE_OUTPUT_SYMLINK", f"output component is a symlink: {absolute}")
             if not stat.S_ISDIR(info.st_mode):
                 fail("UNSAFE_OUTPUT_PATH", f"output component is not a directory: {absolute}")
-            next_fd = os.open(part, flags | nofollow, dir_fd=fd)
+            next_fd = None
+            try:
+                next_fd = os.open(part, flags | nofollow, dir_fd=fd)
+                opened = os.fstat(next_fd)
+                if not same_directory_identity(info, opened):
+                    fail("UNSAFE_OUTPUT_SWAP", f"output component identity changed: {absolute}")
+            except BaseException:
+                if next_fd is not None:
+                    os.close(next_fd)
+                raise
             os.close(fd)
             fd = next_fd
         verify_directory_identity(absolute, fd)
@@ -146,7 +172,7 @@ def verify_directory_identity(path: Path, fd: int) -> None:
     opened = os.fstat(fd)
     if stat.S_ISLNK(named.st_mode) or not stat.S_ISDIR(named.st_mode):
         fail("UNSAFE_OUTPUT_SYMLINK", f"output directory is no longer a real directory: {path}")
-    if (named.st_dev, named.st_ino) != (opened.st_dev, opened.st_ino):
+    if not same_directory_identity(named, opened):
         fail("UNSAFE_OUTPUT_SWAP", f"output directory identity changed: {path}")
 
 

package/.grok/skills/autoresearch/scripts/verify-canonical-corpus.mjs

@@ -11,8 +11,8 @@ const VERIFIER_RELATIVE = 'scripts/verify-canonical-corpus.mjs';
 const EXPECTED = Object.freeze({
   "schemaVersion": "litgrok.autoresearch-corpus/v1",
   "fileCount": 27,
-  "byteCount": 38018,
-  "aggregateSha256": "520a3c79715f484e912439dd0b350b652e30e3e78c8eb278061bfc90174e124c",
+  "byteCount": 38805,
+  "aggregateSha256": "0296ca6e52fb7cb68a37f3e17f148248146955ad9624e37e449e60b56eeeb1d3",
   "files": {
     "assets/report_template.md": "b6b7607488736f24d3bacea8f3ec8563da40ff782cc1d85c064ab53b2488a4f9",
     "assets/research_template.md": "726d175cd2db92dfe58a738117d9c6cc88211e519d3be8fb7cb05b66ba34c050",
@@ -39,7 +39,7 @@ const EXPECTED = Object.freeze({
     "references/modes/ship/type-checklists.md": "6bea500594cad1e23bdeee2df34f6dd079d02b279773b20f914d313cabd630b3",
     "references/results-logging.md": "4671c19df6d389b42091f2f117fd90726cb32f3082b44dbc9a895dc3625b9832",
     "references/visualization-guide.md": "2ca249d74b30b41e7660c8b7ba91a59b0c33a1e74fc18b2ec2f867441a6e4b27",
-    "scripts/init_research.py": "a5434711928eb4d0487d933df5e1b374f8553140004c6ab8e38fe577ae074d05",
+    "scripts/init_research.py": "b675ea22abf0794e32dbbf59b95248f20878bbf3d071fa10d37b5a004a7f880c",
     "scripts/style_presets.py": "b1c7d495016b0737b622684f4381f87990dfaae77934b3acae44e19742ebdfd5"
   }
 });

package/.grok/skills/skill-observer/scripts/skill-loop.mjs

@@ -10,6 +10,7 @@ import {
   fstatSync,
   fsyncSync,
   lstatSync,
+  linkSync,
   mkdirSync,
   openSync,
   readFileSync,
@@ -301,10 +302,119 @@ function validateLockFileSecurity(path, identity) {
   return status;
 }
 
+function sameLockIdentity(left, right) {
+  return left.isFile() === right.isFile()
+    && left.isSymbolicLink() === right.isSymbolicLink()
+    && left.dev === right.dev
+    && left.ino === right.ino
+    && left.uid === right.uid
+    && left.mode === right.mode
+    && left.nlink === right.nlink
+    && left.size === right.size
+    && left.ctimeMs === right.ctimeMs
+    && left.birthtimeMs === right.birthtimeMs;
+}
+
+function sameLockHandle(left, right) {
+  return left.isFile() === right.isFile()
+    && left.isSymbolicLink() === right.isSymbolicLink()
+    && left.dev === right.dev
+    && left.ino === right.ino
+    && left.uid === right.uid
+    && left.mode === right.mode
+    && left.nlink === right.nlink
+    && left.size === right.size;
+}
+
+function sameLockLocation(left, right) {
+  return left.isFile() === right.isFile()
+    && left.isSymbolicLink() === right.isSymbolicLink()
+    && left.dev === right.dev
+    && left.ino === right.ino
+    && left.uid === right.uid
+    && left.nlink === right.nlink;
+}
+
+function inspectLockAgainstDescriptor(path, descriptor, identity, secure) {
+  const named = secure ? validateLockFileSecurity(path, identity) : lstatSync(path);
+  if (!named.isFile() || named.isSymbolicLink() || named.size > 4096 || named.nlink !== 1) fail('STATE_LOCK_INVALID', path);
+  const held = fstatSync(descriptor);
+  if (held.size > 4096) fail('STATE_LOCK_INVALID', path);
+  let reader;
+  try {
+    reader = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const opened = fstatSync(reader);
+    if (!sameLockLocation(opened, held) || opened.size !== named.size) fail('STATE_LOCK_RACE', path);
+    const bytes = readFileSync(reader);
+    const current = secure ? validateLockFileSecurity(path, identity) : lstatSync(path);
+    if (!sameLockLocation(current, held) || current.size !== opened.size) fail('STATE_LOCK_RACE', path);
+    return { bytes, digest: createHash('sha256').update(bytes).digest('hex'), status: current };
+  } finally {
+    if (reader !== undefined) closeSync(reader);
+  }
+}
+
+function restoreMovedLock(path, tombstone) {
+  try {
+    linkSync(tombstone, path);
+    unlinkSync(tombstone);
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error;
+  }
+}
+
+function removePinnedLock(path, descriptor, identity, expected, expectedBytes, code, {
+  secure = false,
+  tokenWritten = true,
+  bytesWritten = Buffer.byteLength(expectedBytes, 'utf8'),
+  faultInjector,
+  phase,
+} = {}) {
+  const bytes = Buffer.from(expectedBytes, 'utf8');
+  const prefix = bytes.subarray(0, bytesWritten);
+  const matches = (entry, beforeRename) => {
+    const identityMatches = secure ? sameLockHandle(entry.status, expected) : sameLockLocation(entry.status, expected);
+    if (!identityMatches) return false;
+    if (tokenWritten ? !entry.bytes.equals(bytes) : !entry.bytes.equals(prefix)) return false;
+    return !beforeRename || tokenWritten || bytesWritten > 0 || sameLockIdentity(entry.status, expected);
+  };
+  let checked;
+  try {
+    checked = inspectLockAgainstDescriptor(path, descriptor, identity, secure);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return 'vanished';
+    throw error;
+  }
+  if (!matches(checked, true)) fail(code, path);
+  faultInjector?.(phase, { path, descriptor, expectedBytes });
+  checked = inspectLockAgainstDescriptor(path, descriptor, identity, secure);
+  if (!matches(checked, true)) fail(code, path);
+  const tombstone = `${path}.cleanup-${process.pid}-${randomUUID()}`;
+  try {
+    renameSync(path, tombstone);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return 'vanished';
+    throw error;
+  }
+  let moved;
+  try {
+    moved = inspectLockAgainstDescriptor(tombstone, descriptor, identity, secure);
+  } catch (error) {
+    restoreMovedLock(path, tombstone);
+    throw error;
+  }
+  if (!matches(moved, false)) {
+    restoreMovedLock(path, tombstone);
+    fail(code, path);
+  }
+  unlinkSync(tombstone);
+  return 'removed';
+}
+
 function readSecureLock(path, identity, options = {}) {
   let expected;
   try {
-    expected = validateLockFileSecurity(path, identity);
+    expected = options.expectedStatus ?? validateLockFileSecurity(path, identity);
   } catch (error) {
     if (options.missingLock === 'propagate' && error?.code === 'ENOENT') throw error;
     throw error instanceof SkillLoopError ? error : new SkillLoopError('STATE_LOCK_INVALID', path);
@@ -313,12 +423,15 @@ function readSecureLock(path, identity, options = {}) {
   try {
     descriptor = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
     const opened = fstatSync(descriptor);
-    if (!opened.isFile() || opened.size > 4096 || opened.nlink !== 1
-      || opened.dev !== expected.dev || opened.ino !== expected.ino) fail('STATE_LOCK_INVALID', path);
-    const contents = readFileSync(descriptor, 'utf8').trim();
+    if (!opened.isFile() || opened.size > 4096 || opened.nlink !== 1 || !sameLockIdentity(opened, expected)) {
+      fail('STATE_LOCK_INVALID', path);
+    }
+    const bytes = readFileSync(descriptor);
+    const contents = bytes.toString('utf8').trim();
+    const digest = createHash('sha256').update(bytes).digest('hex');
     const current = validateLockFileSecurity(path, identity);
-    if (current.dev !== opened.dev || current.ino !== opened.ino || current.size !== opened.size) fail('STATE_LOCK_RACE', path);
-    return { contents, status: current };
+    if (!sameLockIdentity(current, opened)) fail('STATE_LOCK_RACE', path);
+    return { contents, digest, status: current };
   } catch (error) {
     if (error instanceof SkillLoopError) throw error;
     if (options.missingLock === 'propagate' && error?.code === 'ENOENT') throw error;
@@ -344,12 +457,12 @@ function reclaimStaleLock(path, identity, options = {}) {
   options.faultInjector?.('reclaim-read', { path });
   let secureRead;
   try {
-    secureRead = readSecureLock(path, identity, { missingLock: 'propagate' });
+    secureRead = readSecureLock(path, identity, { missingLock: 'propagate', expectedStatus: initial });
   } catch (error) {
     if (error?.code === 'ENOENT') return 'vanished';
     throw error;
   }
-  const { contents, status } = secureRead;
+  const { contents, digest, status } = secureRead;
   let record;
   if (/^[1-9][0-9]{0,14}$/.test(contents)) {
     if (identity.platform === 'win32') fail('STATE_LOCK_INVALID', 'legacy owner unavailable');
@@ -381,57 +494,46 @@ function reclaimStaleLock(path, identity, options = {}) {
     throw error;
   }
   const moved = readSecureLock(tombstone, identity);
-  if (moved.status.dev !== status.dev || moved.status.ino !== status.ino || moved.contents !== contents) {
-    if (!existsSync(path)) renameSync(tombstone, path);
+  if (!sameLockHandle(moved.status, status) || moved.contents !== contents || moved.digest !== digest) {
+    restoreMovedLock(path, tombstone);
     fail('STATE_LOCK_RACE', path);
   }
   unlinkSync(tombstone);
   return 'reclaimed';
 }
 
-function cleanupFailedLockAcquisition(path, descriptor, created, expectedBytes, tokenWritten) {
-  try {
-    closeSync(descriptor);
-  } catch {
-    fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', 'descriptor');
-  }
-  let current;
+function cleanupFailedLockAcquisition(path, descriptor, created, expectedBytes, tokenWritten, bytesWritten, identity, options = {}) {
   try {
-    current = lstatSync(path);
-  } catch {
-    fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', 'missing');
-  }
-  if (!current.isFile() || current.isSymbolicLink() || current.dev !== created.dev || current.ino !== created.ino
-    || current.nlink !== 1 || current.size > 4096) fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', 'identity');
-  let reader;
-  if (tokenWritten) {
     try {
-      reader = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
-      const opened = fstatSync(reader);
-      if (opened.dev !== created.dev || opened.ino !== created.ino || opened.size > 4096
-        || readFileSync(reader, 'utf8') !== expectedBytes) fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', 'token');
+      removePinnedLock(path, descriptor, identity, created, expectedBytes, 'STATE_LOCK_ACQUISITION_CLEANUP_FAILED', {
+        tokenWritten,
+        bytesWritten,
+        faultInjector: options.faultInjector,
+        phase: 'before-acquisition-cleanup-rename',
+      });
     } catch (error) {
-      if (error instanceof SkillLoopError) throw error;
-      fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', 'read');
-    } finally {
-      if (reader !== undefined) closeSync(reader);
+      if (error?.code === 'STATE_LOCK_ACQUISITION_CLEANUP_FAILED') throw error;
+      fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', error?.code ?? 'retargeted');
+    }
+  } finally {
+    try {
+      closeSync(descriptor);
+    } catch {
+      fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', 'descriptor');
     }
   }
-  const final = lstatSync(path);
-  if (final.dev !== created.dev || final.ino !== created.ino || final.nlink !== 1) {
-    fail('STATE_LOCK_ACQUISITION_CLEANUP_FAILED', 'retargeted');
-  }
-  unlinkSync(path);
 }
 
 export function withStateLock(path, operation, attempts = 200, options = {}) {
   safeMkdir(dirname(path));
   const identity = lockIdentity(path);
   let descriptor;
+  let ownerBytes;
   for (let index = 0; index < attempts; index += 1) {
     let created;
     let expectedBytes;
     let tokenWritten = false;
+    let bytesWritten = 0;
     try {
       descriptor = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
       created = fstatSync(descriptor);
@@ -442,12 +544,15 @@ export function withStateLock(path, operation, attempts = 200, options = {}) {
         createdAt: new Date().toISOString(),
         nonce: randomUUID(),
       })}\n`;
+      ownerBytes = expectedBytes;
       const bytes = Buffer.from(expectedBytes, 'utf8');
       let offset = 0;
       while (offset < bytes.length) {
+        options.faultInjector?.('before-token-write', { descriptor, path });
         const written = writeSync(descriptor, bytes, offset, bytes.length - offset);
         if (!Number.isSafeInteger(written) || written < 1) fail('STATE_LOCK_WRITE_FAILED');
         offset += written;
+        bytesWritten = offset;
       }
       tokenWritten = true;
       fsyncSync(descriptor);
@@ -456,7 +561,7 @@ export function withStateLock(path, operation, attempts = 200, options = {}) {
       break;
     } catch (error) {
       if (descriptor !== undefined) {
-        cleanupFailedLockAcquisition(path, descriptor, created, expectedBytes, tokenWritten);
+        cleanupFailedLockAcquisition(path, descriptor, created, expectedBytes, tokenWritten, bytesWritten, identity, options);
         descriptor = undefined;
       }
       if (error?.code !== 'EEXIST') throw error;
@@ -474,13 +579,16 @@ export function withStateLock(path, operation, attempts = 200, options = {}) {
   try {
     return operation();
   } finally {
-    closeSync(descriptor);
     try {
-      const status = validateLockFileSecurity(path, identity);
-      if (status.dev !== owned.dev || status.ino !== owned.ino) fail('STATE_LOCK_OWNERSHIP_LOST', path);
-      unlinkSync(path);
+      removePinnedLock(path, descriptor, identity, owned, ownerBytes, 'STATE_LOCK_OWNERSHIP_LOST', {
+        secure: true,
+        faultInjector: options.faultInjector,
+        phase: 'before-release-rename',
+      });
     } catch (error) {
       if (error?.code !== 'ENOENT') throw error;
+    } finally {
+      closeSync(descriptor);
     }
   }
 }

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.2.6 (pending) — 2026-09-02
+
+- Harden inode-reuse handling across skill-loop state locks and the
+  autoconference/autoresearch output scaffolders: lock reclaim, failed-acquisition
+  cleanup, and release stay bound to descriptor identity, ctime/birthtime, and
+  exact bytes through tombstone checks, while opened output directories are
+  revalidated against full stat identity before publication. Add same-inode race
+  regressions and regenerate the affected canonical manifests so replacements fail
+  closed while authorized rotations remain valid.
+
+## 0.2.5 (pending) — 2026-09-01
+
+- Add the shared stacked LitFamily ASCII wordmark to the installer and lead both
+  READMEs with the version-free wordmark.
+- Add a CI-enforced, manifest-driven version-lockstep guard for all eight release
+  sites, counting both plain and escaped-regex pins.
+- Report model-picker and output-style selection as Grok host limits rather than
+  shipped surfaces: the installer writes no model or style keys, and
+  `grok inspect --json` exposes no `model`, `outputStyles`, or `settings` keys.
+- Add installer-depth coverage for explicit `--yes` consent, non-interactive
+  no-write behavior, host-limit receipts, measured install phases, and isolated
+  plugin validation.
+
 ## 0.2.4 (pending) — 2026-08-31
 
 - Ship the Grok plugin manifest, eleven Grok-native agents, and complete reference

package/README.md

@@ -1,5 +1,18 @@
 <p align="center"><img src="./cover.png" width="100%" alt="LitGrok — Grok Build skills and project rules, installed with npx" /></p>
 
+```text
+██╗     ██╗████████╗
+██║     ██║╚══██╔══╝
+██║     ██║   ██║   
+███████╗██║   ██║   
+╚══════╝╚═╝   ╚═╝   
+ ██████╗ ██████╗  ██████╗ ██╗  ██╗
+██╔════╝ ██╔══██╗██╔═══██╗██║ ██╔╝
+██║  ███╗██████╔╝██║   ██║█████╔╝ 
+╚██████╔╝██║  ██║╚██████╔╝██║  ██╗
+ ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝
+```
+
 <h1 align="center">LitGrok</h1>
 <p align="center">
   <em>Grok Build skills and project rules for evidence-first lit work, installed with <code>npx</code>.</em>
@@ -9,7 +22,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-litgrok--ai-cb3837" alt="npm: litgrok-ai" />
-  <img src="https://img.shields.io/badge/version-0.2.4-2ea44f" alt="version 0.2.4" />
+  <img src="https://img.shields.io/badge/version-0.2.6-2ea44f" alt="version 0.2.6" />
   <img src="https://img.shields.io/badge/Grok%20Build-skills%20%2B%20rules-111827" alt="Grok Build skills and project rules" />
   <img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license" />
 </p>
@@ -18,6 +31,37 @@ LitGrok is the Grok Build member of the lit workflow family. The npm package is
 
 This package does not log in to Grok, start the TUI, or claim live host behavior.
 
+### The workflow in one view
+
+```mermaid
+flowchart TD
+    R["a request<br/>make it better"] --> DI["<b>deep-interview</b><br/>turn it into a decision-complete brief"]
+    DI --> P["<b>lit-plan</b><br/>objective · non-goals<br/>action / output / <b>binary verification</b>"]
+    P --> GATE{"user approves?"}
+    GATE -->|no| P
+    GATE -->|yes| SW["<b>start-work</b><br/>execute one slice"]
+
+    subgraph LOOP["each slice: RED to GREEN to SURFACE to CLEAN"]
+        SW --> RED["failing test first"]
+        RED --> GREEN["smallest change that passes"]
+        GREEN --> SURF["exercise the <b>real surface</b><br/>not just the test"]
+        SURF --> CLEAN["tear down · cleanup receipt"]
+    end
+
+    CLEAN --> EV{"evidence complete?"}
+    EV -->|"tests only"| SW
+    EV -->|"artifact + receipt"| RW["<b>review-work</b><br/>scope · evidence · payload<br/>security · real surface"]
+    RW -->|findings| SW
+    RW -->|clean| HO["<b>lit-handoff</b><br/>resumable packet"]
+
+    style GATE fill:#fff3cd,stroke:#856404
+    style EV fill:#fff3cd,stroke:#856404
+    style SURF fill:#d4edda,stroke:#155724
+    style RW fill:#d1ecf1,stroke:#0c5460
+```
+
+> **Execution discipline.** A plan earns approval only when every item has binary verification. A slice closes after the real surface produces an artifact and its QA resources are torn down; passing tests alone never closes it.
+
 ## What it is
 
 - 34 Grok-native skill documents at `.grok/skills/<name>/SKILL.md`.
@@ -31,6 +75,27 @@ This package does not log in to Grok, start the TUI, or claim live host behavior
 
 Grok Build loads skills from project, user, plugin, and configured paths. Project guidance uses AGENTS-family files and `.grok/rules/*.md`; hooks load from project or user `.grok/hooks/`. LitGrok installs only these documented direct surfaces.
 
+### How it connects to Grok Build
+
+```mermaid
+flowchart LR
+    subgraph GB["Grok Build"]
+        PJ["plugin.json"]; HK["hooks"]; RL["rules"]
+    end
+    subgraph LG["LitGrok plugin"]
+        PLAN["plan gate"]
+        HEDGE["deliverable hedge guard"]
+        LEDGER[("session ledger")]
+    end
+    PJ --> LG
+    HK --> PLAN --> LEDGER
+    HK --> HEDGE
+    RL --> LG
+    LG --> S["34 skills · 11 agents"]
+```
+
+> **A narrow host boundary.** `plugin.json` exposes the package, hooks feed the plan gate and hedge guard, and rules provide project guidance while the session ledger records bounded state. Together these surfaces carry LitGrok’s 34 skills and 11 agents into Grok Build.
+
 ## Install
 
 ```bash
@@ -40,7 +105,7 @@ npx --yes litgrok-ai@latest install
 Pin a version when you need a reproducible install:
 
 ```bash
-npx --yes litgrok-ai@0.2.4 install
+npx --yes litgrok-ai@0.2.6 install
 ```
 
 Preview without writing files:
@@ -87,6 +152,24 @@ If any installed payload file was changed, uninstall refuses the whole removal.
 
 After install, trust project hooks, then open or restart Grok Build in that project. Skills and the rule are guidance surfaces; hook commands are the only executable payload files, and they receive documented event JSON on stdin.
 
+### What the packed payload guarantees
+
+```mermaid
+flowchart LR
+    SK["a skill"] --> Q{"does it declare<br/>a capability?"}
+    Q -->|"self-contained<br/>procedure"| AL["explicit allowlist entry<br/>with a written reason"]
+    Q -->|"needs a corpus"| C["corpus must resolve<br/>inside the <b>packed payload</b>"]
+    AL --> G1
+    C --> G1["<b>payload-substance</b>"]
+    G1 --> G2["<b>cross-product parity</b><br/>one product cannot ship a stub<br/>where the family ships substance"]
+    G2 --> G3["<b>referenced-path resolution</b><br/>every path in a SKILL.md<br/>must exist in the tarball"]
+    G3 --> OK["installs and works<br/>on a machine that has<br/>nothing else"]
+    style C fill:#d4edda,stroke:#155724
+    style OK fill:#d4edda,stroke:#155724
+```
+
+> **The tarball is the shipping boundary.** A file present in the repository is not necessarily shipped. Each `npm pack` gate checks the allowlist or required corpus, parity, and every referenced path, so a missing dependency is caught before release rather than on a user’s machine.
+
 Confirm the files exist:
 
 ```bash
@@ -115,12 +198,12 @@ Review is proposal-only. `autoApply` is always false, transcript text is inert d
 From an installed project, use the package CLI directly when you want a replayable foreground command:
 
 ```bash
-npx --yes litgrok-ai@0.2.4 skill-loop review <session-id>
-npx --yes litgrok-ai@0.2.4 skill-loop list
-npx --yes litgrok-ai@0.2.4 skill-loop apply <proposal-id>
-npx --yes litgrok-ai@0.2.4 skill-loop reject <proposal-id>
-npx --yes litgrok-ai@0.2.4 skill-loop rollback <ledger-id>
-npx --yes litgrok-ai@0.2.4 skill-loop curator
+npx --yes litgrok-ai@0.2.6 skill-loop review <session-id>
+npx --yes litgrok-ai@0.2.6 skill-loop list
+npx --yes litgrok-ai@0.2.6 skill-loop apply <proposal-id>
+npx --yes litgrok-ai@0.2.6 skill-loop reject <proposal-id>
+npx --yes litgrok-ai@0.2.6 skill-loop rollback <ledger-id>
+npx --yes litgrok-ai@0.2.6 skill-loop curator
 ```
 
 `apply` prints the ledger id needed for rollback. The deterministic curator is also user-invoked: by default it runs at most once every seven days, requires at least two idle hours, marks eligible unpinned agent-owned skills stale after 30 idle days, and archives them outside discovery after 90 idle days. It makes a full backup before a transition and never deletes a skill package; `--force` bypasses only the seven-day run interval for an explicit test or maintenance invocation.

package/README_ko-KR.md

@@ -1,5 +1,18 @@
 <p align="center"><img src="./cover.png" width="100%" alt="LitGrok — npx로 설치하는 Grok Build skill과 project rule" /></p>
 
+```text
+██╗     ██╗████████╗
+██║     ██║╚══██╔══╝
+██║     ██║   ██║   
+███████╗██║   ██║   
+╚══════╝╚═╝   ╚═╝   
+ ██████╗ ██████╗  ██████╗ ██╗  ██╗
+██╔════╝ ██╔══██╗██╔═══██╗██║ ██╔╝
+██║  ███╗██████╔╝██║   ██║█████╔╝ 
+╚██████╔╝██║  ██║╚██████╔╝██║  ██╗
+ ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝
+```
+
 <h1 align="center">LitGrok</h1>
 <p align="center">
   <em>Grok Build용 skill과 project rule. <code>npx</code>로 설치합니다.</em>
@@ -9,7 +22,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-litgrok--ai-cb3837" alt="npm: litgrok-ai" />
-  <img src="https://img.shields.io/badge/version-0.2.4-2ea44f" alt="version 0.2.4" />
+  <img src="https://img.shields.io/badge/version-0.2.6-2ea44f" alt="version 0.2.6" />
   <img src="https://img.shields.io/badge/Grok%20Build-skills%20%2B%20rules-111827" alt="Grok Build skills and project rules" />
   <img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license" />
 </p>
@@ -18,6 +31,37 @@ LitGrok은 lit workflow family의 Grok Build 포트입니다. npm 패키지 이
 
 Grok에 로그인하거나 TUI를 띄우거나, live host 동작을 주장하지 않습니다.
 
+### 작업 흐름 한눈에 보기
+
+```mermaid
+flowchart TD
+    R["a request<br/>make it better"] --> DI["<b>deep-interview</b><br/>turn it into a decision-complete brief"]
+    DI --> P["<b>lit-plan</b><br/>objective · non-goals<br/>action / output / <b>binary verification</b>"]
+    P --> GATE{"user approves?"}
+    GATE -->|no| P
+    GATE -->|yes| SW["<b>start-work</b><br/>execute one slice"]
+
+    subgraph LOOP["each slice: RED to GREEN to SURFACE to CLEAN"]
+        SW --> RED["failing test first"]
+        RED --> GREEN["smallest change that passes"]
+        GREEN --> SURF["exercise the <b>real surface</b><br/>not just the test"]
+        SURF --> CLEAN["tear down · cleanup receipt"]
+    end
+
+    CLEAN --> EV{"evidence complete?"}
+    EV -->|"tests only"| SW
+    EV -->|"artifact + receipt"| RW["<b>review-work</b><br/>scope · evidence · payload<br/>security · real surface"]
+    RW -->|findings| SW
+    RW -->|clean| HO["<b>lit-handoff</b><br/>resumable packet"]
+
+    style GATE fill:#fff3cd,stroke:#856404
+    style EV fill:#fff3cd,stroke:#856404
+    style SURF fill:#d4edda,stroke:#155724
+    style RW fill:#d1ecf1,stroke:#0c5460
+```
+
+> **실행 규율.** 모든 항목에 binary verification이 있어야 계획을 승인할 수 있습니다. 한 slice는 실제 surface에서 artifact를 만들고 QA 자원을 정리한 뒤에야 닫힙니다. 테스트만 통과한 상태는 완료가 아닙니다.
+
 ## 무엇을 제공하나요?
 
 - `.grok/skills/<name>/SKILL.md`에 Grok-native skill 문서 34개
@@ -31,6 +75,27 @@ Grok에 로그인하거나 TUI를 띄우거나, live host 동작을 주장하지
 
 Grok Build는 project, user, plugin, configured path에서 skill을 읽습니다. Project guidance는 AGENTS-family 파일과 `.grok/rules/*.md`이고 hook은 project 또는 user `.grok/hooks/`에서 읽습니다. LitGrok은 이 문서화된 direct surface만 설치합니다.
 
+### Grok Build에 연결되는 구조
+
+```mermaid
+flowchart LR
+    subgraph GB["Grok Build"]
+        PJ["plugin.json"]; HK["hooks"]; RL["rules"]
+    end
+    subgraph LG["LitGrok plugin"]
+        PLAN["plan gate"]
+        HEDGE["deliverable hedge guard"]
+        LEDGER[("session ledger")]
+    end
+    PJ --> LG
+    HK --> PLAN --> LEDGER
+    HK --> HEDGE
+    RL --> LG
+    LG --> S["34 skills · 11 agents"]
+```
+
+> **Host 경계는 좁고 명확합니다.** `plugin.json`이 package를 노출하고, hook은 plan gate와 hedge guard로 연결되며, rule은 project guidance가 됩니다. session ledger에는 bounded state를 기록하고, 이 표면들이 34개 skill과 11개 agent를 Grok Build에서 사용할 수 있게 합니다.
+
 ## 설치
 
 ```bash
@@ -40,7 +105,7 @@ npx --yes litgrok-ai@latest install
 재현 가능한 설치는 버전을 고정합니다.
 
 ```bash
-npx --yes litgrok-ai@0.2.4 install
+npx --yes litgrok-ai@0.2.6 install
 ```
 
 파일을 쓰지 않고 미리보기:
@@ -87,6 +152,24 @@ npx --yes litgrok-ai@latest uninstall --user
 
 설치 후 project hook trust를 허용하고, 그 프로젝트에서 Grok Build를 열거나 재시작합니다. Skill과 rule은 guidance surface이고, hook command만 실행 가능한 payload이며 문서화된 event JSON을 stdin으로 받습니다.
 
+### 새 머신에서도 payload가 작동하는 이유
+
+```mermaid
+flowchart LR
+    SK["a skill"] --> Q{"does it declare<br/>a capability?"}
+    Q -->|"self-contained<br/>procedure"| AL["explicit allowlist entry<br/>with a written reason"]
+    Q -->|"needs a corpus"| C["corpus must resolve<br/>inside the <b>packed payload</b>"]
+    AL --> G1
+    C --> G1["<b>payload-substance</b>"]
+    G1 --> G2["<b>cross-product parity</b><br/>one product cannot ship a stub<br/>where the family ships substance"]
+    G2 --> G3["<b>referenced-path resolution</b><br/>every path in a SKILL.md<br/>must exist in the tarball"]
+    G3 --> OK["installs and works<br/>on a machine that has<br/>nothing else"]
+    style C fill:#d4edda,stroke:#155724
+    style OK fill:#d4edda,stroke:#155724
+```
+
+> **Shipping의 기준은 tarball입니다.** 저장소 안에 파일이 있다는 것만으로는 package에 포함됐다고 할 수 없습니다. `npm pack`을 기준으로 allowlist/corpus, product 간 substance parity, `SKILL.md`가 가리키는 path까지 확인하므로 빠진 의존성은 사용자 환경에 도달하기 전에 드러납니다.
+
 파일이 생겼는지 확인:
 
 ```bash
@@ -115,12 +198,12 @@ Review는 proposal만 만듭니다. `autoApply`는 항상 false이고 transcript
 설치된 project에서는 다음 package CLI를 foreground command로 실행할 수 있습니다.
 
 ```bash
-npx --yes litgrok-ai@0.2.4 skill-loop review <session-id>
-npx --yes litgrok-ai@0.2.4 skill-loop list
-npx --yes litgrok-ai@0.2.4 skill-loop apply <proposal-id>
-npx --yes litgrok-ai@0.2.4 skill-loop reject <proposal-id>
-npx --yes litgrok-ai@0.2.4 skill-loop rollback <ledger-id>
-npx --yes litgrok-ai@0.2.4 skill-loop curator
+npx --yes litgrok-ai@0.2.6 skill-loop review <session-id>
+npx --yes litgrok-ai@0.2.6 skill-loop list
+npx --yes litgrok-ai@0.2.6 skill-loop apply <proposal-id>
+npx --yes litgrok-ai@0.2.6 skill-loop reject <proposal-id>
+npx --yes litgrok-ai@0.2.6 skill-loop rollback <ledger-id>
+npx --yes litgrok-ai@0.2.6 skill-loop curator
 ```
 
 `apply`는 rollback에 필요한 ledger id를 출력합니다. Deterministic curator도 user-invoked입니다. 기본적으로 7일에 한 번만 실행되고, 마지막 activity 뒤 최소 2시간이 지나야 하며, pin되지 않은 agent-owned skill을 30일 idle 뒤 stale로 표시하고 90일 idle 뒤 discovery 밖으로 archive합니다. Transition 전에는 전체 backup을 만들고 skill package를 삭제하지 않습니다. `--force`는 명시적인 test 또는 maintenance 실행에서 7일 interval만 건너뜁니다.

package/bin/litgrok.mjs

@@ -7,18 +7,57 @@ import { fileURLToPath } from 'node:url';
 
 const PACKAGE_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const PAYLOAD_ROOT = join(PACKAGE_ROOT, '.grok');
-const USAGE = 'Usage: litgrok [install|uninstall] [--user|--project] [--dry-run] [--no-color]\n       litgrok skill-loop <review|propose|list|apply|reject|rollback|curator> ...\n';
+const USAGE = 'Usage: litgrok [install|uninstall] [--user|--project] [--dry-run] [--no-color] [--yes]\n       litgrok skill-loop <review|propose|list|apply|reject|rollback|curator> ...\n';
+const BRAILLE_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_INTERVAL_MS = 80;
+const CLEAR_LINE = '\r\u001b[2K';
+
+// ANSI Shadow, compressed to 5 rows: the standard 6-row face with its duplicate
+// middle row dropped, keeping the closing row. This matches the approved preview.
+// This table and renderer are ported verbatim from
+// .litclaude/evidence/litfamily-guard-parity-v4/ansi-shadow-authoritative.mjs.
+const GLYPHS = {
+  a:[" █████╗ ","██╔══██╗","███████║","██╔══██║","╚═╝  ╚═╝"],
+  c:[" ██████╗","██╔════╝","██║     ","╚██████╗"," ╚═════╝"],
+  d:["██████╗ ","██╔══██╗","██║  ██║","██████╔╝","╚═════╝ "],
+  e:["███████╗","██╔════╝","█████╗  ","███████╗","╚══════╝"],
+  g:[" ██████╗ ","██╔════╝ ","██║  ███╗","╚██████╔╝"," ╚═════╝ "],
+  h:["██╗  ██╗","██║  ██║","███████║","██║  ██║","╚═╝  ╚═╝"],
+  i:["██╗","██║","██║","██║","╚═╝"],
+  k:["██╗  ██╗","██║ ██╔╝","█████╔╝ ","██║  ██╗","╚═╝  ╚═╝"],
+  l:["██╗     ","██║     ","██║     ","███████╗","╚══════╝"],
+  m:["███╗   ███╗","████╗ ████║","██╔████╔██║","██║ ╚═╝ ██║","╚═╝     ╚═╝"],
+  n:["███╗   ██╗","████╗  ██║","██╔██╗ ██║","██║ ╚████║","╚═╝  ╚═══╝"],
+  o:[" ██████╗ ","██╔═══██╗","██║   ██║","╚██████╔╝"," ╚═════╝ "],
+  p:["██████╗ ","██╔══██╗","██████╔╝","██║     ","╚═╝     "],
+  r:["██████╗ ","██╔══██╗","██████╔╝","██║  ██║","╚═╝  ╚═╝"],
+  s:["███████╗","██╔════╝","███████╗","███████║","╚══════╝"],
+  t:["████████╗","╚══██╔══╝","   ██║   ","   ██║   ","   ╚═╝   "],
+  u:["██╗   ██╗","██║   ██║","██║   ██║","╚██████╔╝"," ╚═════╝ "],
+  x:["██╗  ██╗","╚██╗██╔╝"," ╚███╔╝ ","██╔╝ ██╗","╚═╝  ╚═╝"],
+};
+
+function renderAnsiShadow(word) {
+  const rows = ["", "", "", "", ""];
+  for (const ch of word) {
+    const g = GLYPHS[ch];
+    if (!g) throw new Error(`missing glyph for '${ch}' in '${word}'`);
+    for (let index = 0; index < 5; index += 1) rows[index] += g[index];
+  }
+  return rows;
+}
 
 function parseInstall(args) {
   const remaining = [...args];
   let command = 'install';
   if (['install', 'uninstall'].includes(remaining[0])) command = remaining.shift();
-  if (remaining.some((argument) => !['--user', '--project', '--dry-run', '--no-color'].includes(argument))) return null;
+  if (remaining.some((argument) => !['--user', '--project', '--dry-run', '--no-color', '--yes'].includes(argument))) return null;
   if (remaining.includes('--user') && remaining.includes('--project')) return null;
   return {
     command,
     dryRun: remaining.includes('--dry-run'),
     noColor: remaining.includes('--no-color'),
+    yes: remaining.includes('--yes'),
     scope: remaining.includes('--user') ? 'user' : 'project',
   };
 }
@@ -32,25 +71,168 @@ function packageVersion() {
   }
 }
 
+function paint(value, code, enabled) {
+  return enabled ? `\u001b[${code}m${value}\u001b[0m` : value;
+}
+
+function elapsedSince(start) {
+  return `${(Number(process.hrtime.bigint() - start) / 1e6).toFixed(1)}ms`;
+}
+
+function scopeDescription(options, root) {
+  const alternateFlag = options.scope === 'project' ? '--user' : '--project';
+  const alternateScope = options.scope === 'project' ? 'user' : 'project';
+  return `${options.scope} scope → ${root} (use ${alternateFlag} for ${alternateScope} scope)`;
+}
+
 function printInstallFrame(stdout, options, env, fileCount, root) {
-  const colors = !options.noColor && !Object.hasOwn(env, 'NO_COLOR') && !env.CI && Boolean(stdout.isTTY);
-  const orange = colors ? '' : '';
-  const yellow = colors ? '' : '';
-  const reset = colors ? '' : '';
+  const colors = !options.noColor && !options.dryRun && !Object.hasOwn(env, 'NO_COLOR') && !env.CI && Boolean(stdout.isTTY);
+  const orange = colors ? '\u001b[38;2;255;90;31m' : '';
+  const yellow = colors ? '\u001b[38;2;250;204;21m' : '';
+  const reset = colors ? '\u001b[0m' : '';
   const rule = `  ${'━'.repeat(46)}`;
+  const payloadLabel = Number.isInteger(fileCount) ? `${fileCount} files · byte-identical copies only` : 'packaged .grok tree · byte-identical copies only';
   stdout.write(`${rule}\n`);
   stdout.write('\n');
-  stdout.write(`   ${orange}🔥  l  i  t  grok   v${packageVersion()}${reset}\n`);
+  const wordmarkRows = [
+    ...renderAnsiShadow('lit'),
+    ...renderAnsiShadow('grok').map((row, index) => index === 0 ? `${row}   v${packageVersion()}` : row),
+  ];
+  stdout.write(`${wordmarkRows.map((row) => `   ${orange}${row}${reset}`).join('\n')}\n`);
   stdout.write('       Grok Build skills, project rules, and hooks\n');
   stdout.write('\n');
   stdout.write(`${rule}\n`);
   stdout.write(`  ╭─ ${options.command.toUpperCase()}\n`);
-  stdout.write(`  │ ${yellow}01${reset} · Scope      ${options.scope} → ${root}\n`);
-  stdout.write(`  │ ${yellow}02${reset} · Payload    ${fileCount} files\n`);
+  stdout.write(`  │ ${yellow}01${reset} · Scope      ${scopeDescription(options, root)}\n`);
+  stdout.write(`  │ ${yellow}02${reset} · Payload    ${payloadLabel}\n`);
   stdout.write('  ╰─ whole packaged .grok tree, byte-identical copies only\n');
   stdout.write('  ╭─ MODEL ROUTE\n');
   stdout.write('  │ Model selection: host-owned\n');
   stdout.write('  ╰─ Grok Build owns model and effort; the installer writes no model keys\n');
+  return colors;
+}
+
+function statusMark(status, colors) {
+  if (status === 'ok') return paint('✓', '38;2;80;200;80', colors);
+  if (status === 'failed') return paint('✗', '38;2;230;60;60', colors);
+  return colors ? paint('○', '38;2;148;163;184', true) : '[skip]';
+}
+
+class InstallProgress {
+  constructor(stdout, colors) {
+    this.stdout = stdout;
+    this.colors = colors;
+    this.timer = null;
+    this.frameIndex = 0;
+    this.active = false;
+    this.closed = false;
+  }
+
+  open() {
+    this.stdout.write('  ╭─ INSTALL STEPS\n');
+  }
+
+  start(label) {
+    this.clearTimer();
+    this.active = true;
+    this.frameIndex = 0;
+    this.label = label;
+    if (!this.colors) return;
+    this.render();
+    this.timer = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % BRAILLE_FRAMES.length;
+      this.render();
+    }, SPINNER_INTERVAL_MS);
+    if (typeof this.timer.unref === 'function') this.timer.unref();
+  }
+
+  finish(status, label, detail, elapsed) {
+    this.clearTimer();
+    const suffix = detail ? ` · ${detail}` : '';
+    const line = `  │ ${statusMark(status, this.colors)} ${label}${suffix} · ${elapsed}`;
+    this.stdout.write(this.colors && this.active ? `${CLEAR_LINE}${line}\n` : `${line}\n`);
+    this.active = false;
+  }
+
+  close() {
+    this.clearTimer();
+    if (this.closed) return;
+    this.stdout.write('  ╰─\n');
+    this.closed = true;
+  }
+
+  render() {
+    const frame = paint(BRAILLE_FRAMES[this.frameIndex] ?? BRAILLE_FRAMES[0], '38;2;250;204;21', this.colors);
+    this.stdout.write(`${CLEAR_LINE}  │ ${frame} ${this.label}`);
+  }
+
+  clearTimer() {
+    if (this.timer === null) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+}
+
+function runStep(progress, label, operation) {
+  const started = process.hrtime.bigint();
+  progress.start(label);
+  try {
+    const result = operation();
+    progress.finish('ok', label, result.detail ?? '', elapsedSince(started));
+    return result.value;
+  } catch (error) {
+    progress.finish('failed', label, error instanceof Error ? error.message : String(error), elapsedSince(started));
+    throw error;
+  }
+}
+
+function skipStep(progress, label, detail) {
+  const started = process.hrtime.bigint();
+  progress.finish('skipped', label, detail, elapsedSince(started));
+}
+
+function receiptCard(options, root, colors, { status, written, current }) {
+  const statusColor = status === 'Ready' || status === 'Already current' || status === 'Removed' ? '38;2;80;200;80' : '38;2;230;60;60';
+  const titleColor = status === 'Failed' ? '38;2;230;60;60' : '38;2;255;90;31';
+  return [
+    '',
+    `  ${paint('╭─ INSTALL RECEIPT', titleColor, colors)}`,
+    `  │ Status: ${paint(status, statusColor, colors)}`,
+    `  │ Scope: ${scopeDescription(options, root)}`,
+    `  │ Written vs already-current: ${written} written · ${current} already-current`,
+    '  │ Model route: host-owned; the installer writes no model keys',
+    '  │ Model picker: host limit — Grok Build owns session selection; no model keys are written',
+    '  │ Output styles: host limit — Grok Build exposes no output-style selector; the installer writes no style keys',
+    '  │ Hooks: require trust — /hooks-trust or launch Grok Build with --trust',
+    '  │ Next: restart Grok Build',
+    `  ${paint('╰─', titleColor, colors)}`,
+    '',
+  ].join('\n');
+}
+
+function failureCard(options, root, colors, step, message) {
+  return [
+    '',
+    `  ${paint('╭─ INSTALL FAILED', '38;2;230;60;60', colors)}`,
+    `  │ Status: ${paint('Failed', '38;2;230;60;60', colors)}`,
+    `  │ Scope: ${scopeDescription(options, root)}`,
+    `  │ Step: ${step}`,
+    `  │ Reason: ${message}`,
+    '  │ Hooks: require trust — /hooks-trust or launch Grok Build with --trust',
+    '  │ Next: resolve the issue and rerun the install',
+    `  ${paint('╰─', '38;2;230;60;60', colors)}`,
+    '',
+  ].join('\n');
+}
+
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function reportFailure(error, { stderr, stdout, options, root, colors, step }) {
+  const lines = Array.isArray(error?.stderrLines) ? error.stderrLines : [`litgrok: ${errorText(error)}`];
+  for (const line of lines) stderr.write(`${line}\n`);
+  stdout.write(failureCard(options, root, colors, error?.step ?? step, errorText(error)));
 }
 
 function targetState(source, target) {
@@ -133,19 +315,40 @@ export async function run(args, context = {}) {
 
   const home = env.HOME || env.USERPROFILE || homedir();
   const root = join(options.scope === 'project' ? cwd : home, '.grok');
-  const files = discoverPayloadFiles().map(({ relativePath, source }) => ({
-    relativePath,
-    source,
-    target: join(root, relativePath),
-  }));
-  const projectHooksIncluded =
-    options.command === 'install' && options.scope === 'project' && files.some(({ relativePath }) => relativePath.split(sep)[0] === 'hooks');
+  const displayRoot = resolve(root);
+  const payloadStarted = process.hrtime.bigint();
+  let discoveredPayload;
+  let payloadError;
+  try {
+    discoveredPayload = discoverPayloadFiles();
+  } catch (error) {
+    payloadError = error;
+  }
 
-  function printHookTrustRequirement() {
-    if (projectHooksIncluded) stdout.write('Project hooks require trust before they run: use /hooks-trust or launch Grok Build with --trust.\n');
+  function filesFromPayload(discovered) {
+    return discovered.map(({ relativePath, source }) => ({
+      relativePath,
+      source,
+      target: join(root, relativePath),
+    }));
   }
 
-  printInstallFrame(stdout, options, env, files.length, root);
+  function projectHooksIncluded(files) {
+    return options.command === 'install' && options.scope === 'project' && files.some(({ relativePath }) => relativePath.split(sep)[0] === 'hooks');
+  }
+
+  function printHookTrustRequirement(files) {
+    if (projectHooksIncluded(files)) stdout.write('Project hooks require trust before they run: use /hooks-trust or launch Grok Build with --trust.\n');
+  }
+
+  const files = discoveredPayload ? filesFromPayload(discoveredPayload) : null;
+  const payloadElapsed = payloadError ? null : elapsedSince(payloadStarted);
+  const colors = printInstallFrame(stdout, options, env, files?.length, displayRoot);
+
+  if (payloadError) {
+    reportFailure(payloadError, { stderr, stdout, options, root: displayRoot, colors, step: 'PAYLOAD' });
+    return 1;
+  }
 
   const reasons = [];
   if (options.dryRun) reasons.push('DRY RUN');
@@ -155,52 +358,104 @@ export async function run(args, context = {}) {
   if (reasons.length > 0) {
     stdout.write(`${reasons.join(' / ')} — no files written\n`);
     for (const { target } of files) stdout.write(`would ${options.command} ${target}\n`);
-    printHookTrustRequirement();
+    printHookTrustRequirement(files);
     return 0;
   }
 
-  const unsafeAncestor = unsafeInstallAncestor(root, files);
-  if (unsafeAncestor) {
-    stderr.write(`Refusing ${unsafeAncestor.reason} in install path: ${unsafeAncestor.path}\n`);
-    return 1;
-  }
+  const progress = new InstallProgress(stdout, colors);
+  progress.open();
+  let step = 'PAYLOAD';
+  try {
+    progress.finish('ok', 'PAYLOAD', `${files.length} files discovered`, payloadElapsed);
+
+    step = 'SAFETY';
+    runStep(progress, 'SAFETY', () => {
+      const unsafe = unsafeInstallAncestor(root, files);
+      if (unsafe) {
+        const message = `Refusing ${unsafe.reason} in install path: ${unsafe.path}`;
+        const error = new Error(message);
+        error.step = 'SAFETY';
+        error.stderrLines = [message];
+        throw error;
+      }
+      return { value: null, detail: 'install path clear' };
+    });
+
+    step = 'OWNERSHIP';
+    const states = runStep(progress, 'OWNERSHIP', () => {
+      const owned = files.map(({ source, target }) => targetState(source, target));
+      const counts = {
+        missing: owned.filter((state) => state === 'missing').length,
+        current: owned.filter((state) => state === 'current').length,
+        conflicts: owned.filter((state) => state === 'conflict').length,
+      };
+      if (counts.conflicts > 0) {
+        const stderrLines = [];
+        for (let index = 0; index < files.length; index += 1) {
+          if (owned[index] === 'conflict') stderrLines.push(`Refusing to ${options.command === 'install' ? 'overwrite' : 'remove'} different existing file: ${files[index].target}`);
+        }
+        const error = new Error(`${counts.missing} missing · ${counts.current} already-current · ${counts.conflicts} conflicts`);
+        error.step = 'OWNERSHIP';
+        error.stderrLines = stderrLines;
+        throw error;
+      }
+      return {
+        value: { states: owned, counts },
+        detail: `${counts.missing} missing · ${counts.current} already-current · ${counts.conflicts} conflicts`,
+      };
+    });
 
-  const states = files.map(({ source, target }) => targetState(source, target));
-  if (states.includes('conflict')) {
-    for (let index = 0; index < files.length; index += 1) {
-      if (states[index] === 'conflict') stderr.write(`Refusing to ${options.command === 'install' ? 'overwrite' : 'remove'} different existing file: ${files[index].target}\n`);
+    step = 'WRITE';
+    if (options.command === 'uninstall') {
+      const writeStarted = process.hrtime.bigint();
+      progress.start('WRITE');
+      let removed = 0;
+      for (let index = 0; index < files.length; index += 1) {
+        if (states.states[index] !== 'current') continue;
+        unlinkSync(files[index].target);
+        removed += 1;
+      }
+      progress.finish('ok', 'WRITE', `${removed} removed · ${states.counts.missing} already absent`, elapsedSince(writeStarted));
+      const receipt = receiptCard(options, displayRoot, colors, { status: 'Removed', written: 0, current: states.counts.current });
+      progress.close();
+      stdout.write(receipt);
+      return 0;
     }
-    return 1;
-  }
 
-  if (options.command === 'uninstall') {
-    let removed = 0;
-    for (let index = 0; index < files.length; index += 1) {
-      if (states[index] !== 'current') continue;
-      unlinkSync(files[index].target);
-      removed += 1;
+    if (states.states.every((state) => state === 'current')) {
+      skipStep(progress, 'WRITE', `SKIPPED · 0 written · ${states.counts.current} already-current`);
+      const receipt = receiptCard(options, displayRoot, colors, { status: 'Already current', written: 0, current: states.counts.current });
+      progress.close();
+      stdout.write(receipt);
+      return 0;
     }
-    stdout.write(removed === 0 ? `Already absent: ${files.length} files\n` : `Removed ${removed} files\n`);
-    return 0;
-  }
 
-  if (states.every((state) => state === 'current')) {
-    stdout.write(`Already current: ${files.length} files\n`);
-    printHookTrustRequirement();
+    const writeStarted = process.hrtime.bigint();
+    progress.start('WRITE');
+    let installed = 0;
+    try {
+      for (let index = 0; index < files.length; index += 1) {
+        if (states.states[index] === 'current') continue;
+        const { source, target } = files[index];
+        mkdirSync(dirname(target), { recursive: true });
+        copyFileSync(source, target, constants.COPYFILE_EXCL);
+        installed += 1;
+      }
+      progress.finish('ok', 'WRITE', `${installed} written · ${states.counts.current} already-current`, elapsedSince(writeStarted));
+    } catch (error) {
+      progress.finish('failed', 'WRITE', errorText(error), elapsedSince(writeStarted));
+      if (error && typeof error === 'object') error.step = 'WRITE';
+      throw error;
+    }
+    const receipt = receiptCard(options, displayRoot, colors, { status: 'Ready', written: installed, current: states.counts.current });
+    progress.close();
+    stdout.write(receipt);
     return 0;
+  } catch (error) {
+    progress.close();
+    reportFailure(error, { stderr, stdout, options, root: displayRoot, colors, step });
+    return 1;
   }
-
-  let installed = 0;
-  for (let index = 0; index < files.length; index += 1) {
-    if (states[index] === 'current') continue;
-    const { source, target } = files[index];
-    mkdirSync(dirname(target), { recursive: true });
-    copyFileSync(source, target, constants.COPYFILE_EXCL);
-    installed += 1;
-  }
-  stdout.write(`Installed ${installed} files\n`);
-  printHookTrustRequirement();
-  return 0;
 }
 
 if (process.argv[1] && realpathSync(resolve(process.argv[1])) === fileURLToPath(import.meta.url)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "litgrok-ai",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Grok Build skills, project rules, and hooks installer.",
   "type": "module",
   "bin": {
@@ -8,7 +8,8 @@
     "litgrok": "bin/litgrok.mjs"
   },
   "scripts": {
-    "test": "node --test test/*.test.mjs"
+    "test": "node --test test/*.test.mjs",
+    "check:version": "node tools/check-version-lockstep.mjs"
   },
   "files": [
     "plugin.json",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "litgrok",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Grok Build skills, project rules, and bounded lifecycle hooks for evidence-first lit work.",
   "author": {
     "name": "LitGrok contributors"