@ngockhoale/ukit 3.0.10 → 3.0.11

package/template_project/.claude/hooks/auto-prune-bash.sh

@@ -32,10 +32,24 @@ fi
 
 NOW_UTC=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
-node -e '
-// Deadline must exceed the bounded lock wait in this block (maxWaitMs = 5000) so the
-// watchdog can never fire while the mutation is still legally waiting for the lock.
+# Single locked read-modify-write for settings.local.json + permission-usage.json —
+# the same serialization point auto-allow-bash.sh uses (<usage>.lock). See the
+# auto-allow header for the full rationale: a stale-snapshot rewrite can silently
+# drop allow rules, and Claude Code re-reads settings.local.json so a torn write
+# would drop the ENTIRE allow list.
+#
+# TASK-008 fail-closed policy (same as auto-allow-bash, TASK-028): the acquisition
+# budget derives from the remaining hook deadline minus a cleanup reserve, capped
+# at a short slice. On busy/abort — or a missing runtime module on a degraded
+# install — the mutation is SKIPPED (fail closed): sensitive permission state is
+# never written unlocked. The old inline lock ran fn() UNLOCKED on non-EEXIST
+# errors and after maxWaitMs (C79-10).
+UKIT_RUNTIME_DIR="$SCRIPT_DIR/../ukit/runtime" node -e '
+// Deadline must exceed the derived lock budget in this block (remaining deadline
+// minus reserve, capped at a short slice) so the watchdog can never fire while
+// the mutation is still legally waiting for the lock.
 const HOOK_DEADLINE_MS = Number.parseInt(process.env.UKIT_HOOK_DEADLINE_MS || "", 10) || 8000;
+const LOCK_STARTED_AT = Date.now();
 
 // SPEC §8: a failed prune abandons configured work — announce it (success stays silent).
 // Unpruned rules are harmless (stale entries simply never match again), so degrade is
@@ -52,9 +66,9 @@ setTimeout(() => {
   emitDegrade("prune exceeded its deadline; stale Bash auto-allow rules were not pruned this session — the next session retries.");
   process.exit(0);
 }, HOOK_DEADLINE_MS).unref();
-const crypto = require("crypto");
 const fsp = require("fs").promises;
 const path = require("path");
+const { pathToFileURL } = require("url");
 
 const settingsPath = process.argv[1];
 const usagePath = process.argv[2];
@@ -63,6 +77,15 @@ const ttlDays = Math.max(1, Number(process.argv[4]) || 30);
 const nowUtc = process.argv[5];
 const cutoff = Date.now() - ttlDays * 24 * 60 * 60 * 1000;
 
+async function pathExists(filePath) {
+  try {
+    await fsp.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function readJson(filePath) {
   try {
     return JSON.parse(await fsp.readFile(filePath, "utf8"));
@@ -118,84 +141,7 @@ async function pruneAuditLog() {
   await fsp.rename(tempPath, auditPath);
 }
 
-// Same lock point as auto-allow-bash.sh (<usage>.lock): the two hooks serialize their
-// settings/usage rewrites against each other and against parallel invocations. Atomic
-// writes because Claude Code re-reads settings.local.json — a torn write would drop the
-// ENTIRE allow list and every command would prompt again. Fail-open after 5s: a hook
-// must never hang the chain.
-function isPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error?.code === "EPERM";
-  }
-}
-
-async function readLockOwner(lockPath) {
-  const owner = await readJson(path.join(lockPath, "owner"));
-  return owner && Number.isInteger(owner.pid) && typeof owner.token === "string"
-    ? owner
-    : null;
-}
-
-async function withLock(lockPath, fn) {
-  const staleMs = 10000;
-  const maxWaitMs = 5000;
-  const startedAt = Date.now();
-  const ownerToken = `${process.pid}-${crypto.randomBytes(8).toString("hex")}`;
-  let held = false;
-  while (!held) {
-    try {
-      await fsp.mkdir(path.dirname(lockPath), { recursive: true });
-      await fsp.mkdir(lockPath);
-      try {
-        await fsp.writeFile(path.join(lockPath, "owner"), JSON.stringify({
-          pid: process.pid,
-          token: ownerToken,
-          ts: Date.now(),
-        }));
-      } catch (error) {
-        try {
-          await fsp.rm(lockPath, { recursive: true, force: true });
-        } catch {}
-        throw error;
-      }
-      held = true;
-    } catch (error) {
-      if (!error || error.code !== "EEXIST") return fn();
-      try {
-        const stat = await fsp.stat(lockPath);
-        if (Date.now() - stat.mtimeMs > staleMs) {
-          const owner = await readLockOwner(lockPath);
-          if (!owner || !isPidAlive(owner.pid)) {
-            try {
-              await fsp.rm(lockPath, { recursive: true, force: true });
-              continue;
-            } catch {}
-          }
-        }
-      } catch {}
-      if (Date.now() - startedAt > maxWaitMs) break;
-      await new Promise((resolve) => setTimeout(resolve, 3 + Math.floor(Math.random() * 9)));
-    }
-  }
-  try {
-    return await fn();
-  } finally {
-    if (held) {
-      const owner = await readLockOwner(lockPath);
-      if (owner?.token === ownerToken) {
-        try {
-          await fsp.rm(lockPath, { recursive: true, force: true });
-        } catch {}
-      }
-    }
-  }
-}
-
-withLock(`${usagePath}.lock`, async () => {
+async function pruneMutation() {
   // Rotate the audit log inside the same lock as the rule prune: both are
   // read-modify-write passes on files these two hooks share.
   await pruneAuditLog();
@@ -235,7 +181,38 @@ withLock(`${usagePath}.lock`, async () => {
   if (prunedCount > 0) {
     await appendAudit("auto_prune_summary", { prunedCount, ttlDays });
   }
-}).catch((error) => {
+}
+
+(async () => {
+  // Fail-closed shared lock (TASK-008, same contract as auto-allow-bash.sh):
+  // the lock lives beside the usage file, and a degraded install without the
+  // runtime module must SKIP the prune rather than write permission state
+  // unlocked — unpruned rules are harmless, torn/lost writes are not.
+  const runtimeDir = process.env.UKIT_RUNTIME_DIR || "";
+  const lockModulePath = runtimeDir ? path.join(runtimeDir, "async-lock.mjs") : "";
+  let lockModule = null;
+  if (lockModulePath && (await pathExists(lockModulePath))) {
+    try {
+      lockModule = await import(pathToFileURL(lockModulePath).href);
+    } catch {
+      lockModule = null;
+    }
+  }
+  if (!lockModule || typeof lockModule.withAsyncLock !== "function") {
+    // Degraded install (runtime module missing): fail closed — skip the write,
+    // exit 0, retry next session.
+    return;
+  }
+  const deadlineMs = lockModule.lockBudgetMs({
+    hookDeadlineMs: HOOK_DEADLINE_MS,
+    startedAt: LOCK_STARTED_AT,
+  });
+  const outcome = await lockModule.withAsyncLock(usagePath, { deadlineMs }, pruneMutation);
+  if (!outcome.ok) {
+    // busy or aborted: fail closed — write nothing unlocked, exit 0.
+    return;
+  }
+})().catch((error) => {
   emitDegrade(`prune failed (${error?.message ?? error}); stale Bash auto-allow rules were not pruned this session — the next session retries.`);
   process.exit(0);
 });

package/template_project/.claude/hooks/block-dangerous.mjs

@@ -133,23 +133,45 @@ const basename = (token) => token.split('/').pop();
 // caller fails closed, never silently allows). UKIT_REALPATH_MISSING=1 (set by
 // the wrapper when no system realpath exists) forces the same fail-closed —
 // the pre-port gate could not prove containment without realpath.
-function canonicalPath(p, env) {
+//
+// TASK-007 (C79-09): every fs probe below is ASYNC (libuv) and raced against
+// the remaining scan budget — never realpathSync/lstatSync. A sync probe on a
+// stalled mount pins the event loop, so runHook's Promise.race deadline timer
+// can never fire and the gate freezes instead of refusing. A timed-out or
+// erroring probe degrades to the lexical ancestor walk; a timed-out final
+// realpath returns '' => downstream fail-closed.
+const FS_OP_BUDGET_MS = 3000;
+
+function timedFs(op, deadlineMs, signal) {
+  if (signal && signal.aborted) return Promise.reject(new Error('aborted'));
+  const budget = Number.isFinite(deadlineMs) ? deadlineMs : FS_OP_BUDGET_MS;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error('fs probe timed out')), Math.max(0, budget));
+    if (timer && typeof timer.unref === 'function') timer.unref();
+  });
+  return Promise.race([op(), timeout]).finally(() => clearTimeout(timer));
+}
+
+async function canonicalPath(p, env, deadlineMs, signal) {
   if (env && env.UKIT_REALPATH_MISSING === '1') return '';
+  const deadlineAt = Date.now() + (Number.isFinite(deadlineMs) ? deadlineMs : FS_OP_BUDGET_MS);
+  const remaining = () => deadlineAt - Date.now();
   try {
-    const out = fs.realpathSync.native(p);
+    const out = await timedFs(() => fsp.realpath(p), remaining(), signal);
     if (out) return out;
   } catch {}
   let rest = '';
   let cur = p;
-  const existsOrLink = (q) => {
+  const existsOrLink = async (q) => {
     try {
-      fs.lstatSync(q);
+      await timedFs(() => fsp.lstat(q), remaining(), signal);
       return true;
     } catch {
       return false;
     }
   };
-  while (cur && cur !== '/' && !existsOrLink(cur)) {
+  while (cur && cur !== '/' && !(await existsOrLink(cur))) {
     rest = `/${path.basename(cur)}${rest}`;
     const parent = cur.slice(0, cur.lastIndexOf('/')) || (cur.startsWith('/') ? '/' : cur);
     if (parent === cur) break;
@@ -157,15 +179,18 @@ function canonicalPath(p, env) {
   }
   if (!cur) cur = '/';
   try {
-    const out = fs.realpathSync.native(cur);
+    const out = await timedFs(() => fsp.realpath(cur), remaining(), signal);
     return `${out}${rest}`;
   } catch {
     return '';
   }
 }
 
-function evaluate({ command, projectRoot, env }) {
+async function evaluate({ command, projectRoot, env, deadlineMs, signal }) {
   if (!command) return { code: 0, stdout: '', stderr: '' };
+  if (signal && signal.aborted) return TIMEOUT_REFUSAL;
+  const deadlineAt = Date.now() + (Number.isFinite(deadlineMs) ? deadlineMs : FS_OP_BUDGET_MS);
+  const remaining = () => deadlineAt - Date.now();
 
   // Quoted-span scrub: only when the invoked command is a pure text tool AND
   // its output cannot reach a shell — `echo "rm -rf /" | bash` executes the
@@ -185,7 +210,7 @@ function evaluate({ command, projectRoot, env }) {
   }
 
   // rm handling: allow safe cleanup targets only; everything else defers.
-  const projectRootCanon = canonicalPath(projectRoot, env);
+  const projectRootCanon = await canonicalPath(projectRoot, env, remaining(), signal);
 
   let verdictUnsafe = false;
   let verdictGeneric = false;
@@ -251,7 +276,7 @@ function evaluate({ command, projectRoot, env }) {
           allSafe = false;
         } else {
           const abs = target.startsWith('/') ? target : `${projectRootCanon}/${target}`;
-          const canon = canonicalPath(abs, env);
+          const canon = await canonicalPath(abs, env, remaining(), signal);
           if (!projectRootCanon || !canon || !canon.startsWith(`${projectRootCanon}/`)) {
             allSafe = false;
           }
@@ -321,7 +346,13 @@ export async function runHook(ctx) {
   try {
     const run = (async () => {
       if (ctx && ctx.signal && ctx.signal.aborted) return TIMEOUT_REFUSAL;
-      return evaluate({ command: extracted.command, projectRoot, env });
+      return evaluate({
+        command: extracted.command,
+        projectRoot,
+        env,
+        deadlineMs,
+        signal: ctx && ctx.signal,
+      });
     })();
     return await Promise.race([run, timeout]);
   } catch {
@@ -366,7 +397,7 @@ async function main() {
   try {
     const extracted = extractCommand({ rawInput, env });
     const command = extracted.unparseable ? '' : extracted.command;
-    const verdict = evaluate({ command, projectRoot, env });
+    const verdict = await evaluate({ command, projectRoot, env, deadlineMs: HOOK_DEADLINE_MS });
     if (verdict.stdout) process.stdout.write(verdict.stdout);
     if (verdict.stderr) process.stderr.write(verdict.stderr);
     process.exit(verdict.code);

package/template_project/.claude/skills/docs-manager/init-project-docs.sh

@@ -1,7 +1,8 @@
 #!/bin/bash
+set -euo pipefail
 
 # Script khởi tạo docs cho project mới
-# Usage: ./init-project-docs.sh "Project Name"
+# Usage: ./init-project-docs.sh "Project Name" [author]
 
 PROJECT_NAME=${1:-"New Project"}
 AUTHOR=${2:-$(git config user.name 2>/dev/null || echo "Developer")}
@@ -12,40 +13,82 @@ echo "📅 Date: $DATE"
 echo "👤 Author: $AUTHOR"
 echo ""
 
+# C80-19: verify every template exists BEFORE touching ./docs — previously a
+# missing template + redirect produced empty files while `rm -rf ./docs` had
+# already destroyed the old docs (data loss).
+SKILL_DIR="$HOME/.claude/skills/docs-manager/templates"
+TEMPLATES=(
+    "README.md.template:docs/README.md"
+    "project.md.template:docs/project.md"
+    "memory.md.template:docs/memory.md"
+    "agent-roles.md.template:docs/agents/agent-roles.md"
+    "coding-conventions.md.template:docs/standards/coding-conventions.md"
+    "onboarding.md.template:docs/guides/onboarding.md"
+)
+missing=0
+for pair in "${TEMPLATES[@]}"; do
+    tpl="${pair%%:*}"
+    if [ ! -f "$SKILL_DIR/$tpl" ]; then
+        echo "❌ Missing template: $SKILL_DIR/$tpl" >&2
+        missing=1
+    fi
+done
+if [ "$missing" -ne 0 ]; then
+    echo "❌ Templates incomplete — aborting without touching docs/" >&2
+    exit 1
+fi
+
 # Kiểm tra đã có docs/ chưa
 if [ -d "./docs" ]; then
     echo "⚠️  Warning: docs/ folder already exists!"
-    read -p "Overwrite? (y/N): " -n 1 -r
+    read -p "Overwrite? (y/N): " -n 1 -r || true
     echo
-    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    if [[ ! ${REPLY:-} =~ ^[Yy]$ ]]; then
         echo "❌ Cancelled"
         exit 1
     fi
-    rm -rf ./docs
+    # C80-19: preserve the old tree by renaming it BEFORE any write — the
+    # previous script ran `rm -rf ./docs` up front, so a failure destroyed docs.
+    backup_dir="./docs.bak-$(date +%Y%m%d-%H%M%S)"
+    mv "./docs" "$backup_dir"
+    echo "🗂️  Previous docs preserved at $backup_dir (remove manually when satisfied)"
 fi
 
 # Tạo cấu trúc
 echo "📁 Creating folder structure..."
 mkdir -p docs/{architecture,agents/prompts,standards,workflows,context,guides,models,integrations}
 
-# Copy templates
-SKILL_DIR="$HOME/.claude/skills/docs-manager/templates"
-
 echo "📄 Creating files from templates..."
 
-# Function replace placeholders
+# Escape replacement text for sed (&, \, |, /, newlines) — C80-19: an
+# unescaped metachar in PROJECT_NAME/AUTHOR corrupted output or broke sed.
+sed_escape() {
+    printf '%s' "$1" | sed -e 's/[&|\\\/]/\\&/g'
+}
+PROJECT_NAME_E=$(sed_escape "$PROJECT_NAME")
+AUTHOR_E=$(sed_escape "$AUTHOR")
+DATE_E=$(sed_escape "$DATE")
+
 replace_placeholders() {
     local file=$1
-    sed "s/{{PROJECT_NAME}}/$PROJECT_NAME/g; s/{{AUTHOR}}/$AUTHOR/g; s/{{DATE}}/$DATE/g" "$file"
+    sed "s/{{PROJECT_NAME}}/$PROJECT_NAME_E/g; s/{{AUTHOR}}/$AUTHOR_E/g; s/{{DATE}}/$DATE_E/g" "$file"
+}
+
+# Write to a temp file first; only install on success so a sed failure never
+# leaves an empty/partial doc.
+gen_doc() {
+    local tpl=$1 dest=$2
+    local tmp
+    tmp=$(mktemp)
+    replace_placeholders "$SKILL_DIR/$tpl" > "$tmp"
+    mv "$tmp" "$dest"
 }
 
-# Copy và replace
-replace_placeholders "$SKILL_DIR/README.md.template" > docs/README.md
-replace_placeholders "$SKILL_DIR/project.md.template" > docs/project.md
-replace_placeholders "$SKILL_DIR/memory.md.template" > docs/memory.md
-replace_placeholders "$SKILL_DIR/agent-roles.md.template" > docs/agents/agent-roles.md
-replace_placeholders "$SKILL_DIR/coding-conventions.md.template" > docs/standards/coding-conventions.md
-replace_placeholders "$SKILL_DIR/onboarding.md.template" > docs/guides/onboarding.md
+for pair in "${TEMPLATES[@]}"; do
+    tpl="${pair%%:*}"
+    dest="${pair#*:}"
+    gen_doc "$tpl" "$dest"
+done
 
 # Tạo empty files
 echo "📝 Creating placeholder files..."

package/template_project/.claude/skills/docx/scripts/document.py

@@ -639,11 +639,17 @@ class Document:
         # Create temporary directory with subdirectories for unpacked content and baseline
         self.temp_dir = tempfile.mkdtemp(prefix="docx_")
         self.unpacked_path = Path(self.temp_dir) / "unpacked"
-        shutil.copytree(self.original_path, self.unpacked_path)
-
-        # Pack original directory into temporary .docx for validation baseline (outside unpacked dir)
-        self.original_docx = Path(self.temp_dir) / "original.docx"
-        pack_document(self.original_path, self.original_docx, validate=False)
+        try:
+            shutil.copytree(self.original_path, self.unpacked_path)
+
+            # Pack original directory into temporary .docx for validation baseline (outside unpacked dir)
+            self.original_docx = Path(self.temp_dir) / "original.docx"
+            pack_document(self.original_path, self.original_docx, validate=False)
+        except Exception:
+            # C80-20: a failed constructor must not rely on __del__ timing —
+            # clean the temp dir right here before the exception propagates.
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+            raise
 
         self.word_path = self.unpacked_path / "word"
 
@@ -830,10 +836,27 @@ class Document:
         self.next_comment_id += 1
         return comment_id
 
+    def close(self):
+        """Release the temp working tree (C80-20: deterministic, not __del__)."""
+        temp_dir = getattr(self, "temp_dir", None)
+        if temp_dir and Path(temp_dir).exists():
+            shutil.rmtree(temp_dir, ignore_errors=True)
+        self.temp_dir = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.close()
+        return False
+
     def __del__(self):
-        """Clean up temporary directory on deletion."""
-        if hasattr(self, "temp_dir") and Path(self.temp_dir).exists():
-            shutil.rmtree(self.temp_dir)
+        # Safety net only — callers should use `with` or close() explicitly;
+        # __del__ timing is non-deterministic (GC cycles, interpreter kill).
+        try:
+            self.close()
+        except Exception:
+            pass
 
     def validate(self) -> None:
         """

package/template_project/.claude/skills/frontend-vue/composables/indexDBStore.js

@@ -73,6 +73,10 @@ export const addDataIDB = async (storage, data) => {
     return new Promise((resolve, reject) => {
         try{
             let transaction = db.transaction([storage], 'readwrite');
+            // C80-16: transaction abort must settle the outer promise.
+            transaction.onerror = () => {
+                reject('Error writing to object store (transaction failed)');
+            };
             let objectStore = transaction.objectStore(storage);
             let clearRequest = objectStore.clear();
 
@@ -89,9 +93,13 @@ export const addDataIDB = async (storage, data) => {
                     resolve(); // Resolve immediately if no data is provided
                 }
             }
+            clearRequest.onerror = () => {
+                reject('Error clearing object store');
+            };
         } catch (e) {
             window.indexedDB.deleteDatabase(db_state.DB_NAME);
             createStoreIDB(storage);
+            reject(e); // C80-16: never leave the await hanging
         }
         
     });
@@ -114,23 +122,36 @@ export const getDataIDB = async (storage) => {
                 return;
             }
             let trans = db.transaction([storage],'readonly');
+            let store = trans.objectStore(storage);
+            let to_return = [];
+
             trans.oncomplete = e => {
                 resolve(to_return[0]);
             };
-            
-            let store = trans.objectStore(storage);
-            let to_return = [];
-            
-            store.openCursor().onsuccess = e => {
+            // C80-15: a failed transaction/cursor must settle the promise —
+            // previously the outer await hung forever.
+            trans.onerror = () => {
+                resolve([]);
+            };
+            trans.onabort = () => {
+                resolve([]);
+            };
+
+            const cursorRequest = store.openCursor();
+            cursorRequest.onsuccess = e => {
                 let cursor = e.target.result;
                 if (cursor) {
                     to_return.push(cursor.value)
                     cursor.continue();
                 }
             };
+            cursorRequest.onerror = () => {
+                resolve(to_return[0] ?? []);
+            };
         } catch (e) {
             window.indexedDB.deleteDatabase(db_state.DB_NAME);
             createStoreIDB(storage);
+            resolve([]); // C80-15: never leave the await hanging
         }
 	});
 };

package/template_project/.claude/skills/frontend-vue/composables/useRequest.js

@@ -70,10 +70,6 @@ export const request_origin = async (url, data = {}, method = "post") => {
       state.loading = true;
     }
     let response = await ax[method.toLowerCase()](url, data);
-    state.loading_count -= 1;
-    if (state.loading_count === 0) {
-      state.loading = false;
-    }
     if(typeof response?.data === 'object'){
       return response?.data;
     } else {
@@ -82,6 +78,14 @@ export const request_origin = async (url, data = {}, method = "post") => {
     }
   } catch {
     return [];
+  } finally {
+    // C80-11: decrement on every path — a thrown request must not wedge the
+    // global loading spinner forever.
+    state.loading_count -= 1;
+    if (state.loading_count <= 0) {
+      state.loading_count = 0;
+      state.loading = false;
+    }
   }
 };
 /**
@@ -128,15 +132,19 @@ export const request = async (url, data = {}, method = "post", with_loading=true
       const gzipBuffer = decompressData(response?.data);
       to_return = JSON.parse(gzipBuffer);
     }
+    return to_return;
+  } catch {
+    return [];
+  } finally {
+    // C80-09: decrement on every path — a thrown request must not wedge the
+    // global loading spinner forever.
     if(with_loading){
       state.loading_count -= 1;
-      if (state.loading_count === 0) {
+      if (state.loading_count <= 0) {
+        state.loading_count = 0;
         state.loading = false;
       }
     }
-    return to_return;
-  } catch {
-    return [];
   }
 };
 
@@ -174,15 +182,19 @@ export const requestForm = async (url, data = {}, method = "post", with_loading=
       const gzipBuffer = decompressData(response?.data);
       to_return = JSON.parse(gzipBuffer);
     }
+    return to_return;
+  } catch {
+    return [];
+  } finally {
+    // C80-10: decrement on every path — a thrown request must not wedge the
+    // global loading spinner forever.
     if(with_loading){
       state.loading_count -= 1;
-      if (state.loading_count === 0) {
+      if (state.loading_count <= 0) {
+        state.loading_count = 0;
         state.loading = false;
       }
     }
-    return to_return;
-  } catch {
-    return [];
   }
 };
 

package/template_project/.claude/skills/frontend-vue/composables/useSession.js

@@ -120,19 +120,24 @@ export const getSession = (key) => {
   if (process.client) {
     const storedSession = localStorage.getItem(SESSION_KEY)
     if (storedSession) {
-      const { data, expiry, hash } = JSON.parse(storedSession)
-      // check hash
-      const check_hash = encrypt_string(expiry.toString());
-      if (hash !== check_hash) {
-        clearSession();
-        return undefined;
-      } else {
-        if (expiry > Date.now()) {
-          session.value = data
-          return session.value[key]
+      try {
+        const { data, expiry, hash } = JSON.parse(storedSession)
+        // check hash — C80-14: non-JSON or a blob missing expiry/hash must
+        // clear + return undefined, not throw into page guards.
+        const check_hash = encrypt_string(expiry.toString());
+        if (hash !== check_hash) {
+          clearSession();
+          return undefined;
         } else {
-          clearSession()
+          if (expiry > Date.now()) {
+            session.value = data
+            return session.value[key]
+          } else {
+            clearSession()
+          }
         }
+      } catch {
+        clearSession()
       }
     }
   }