@ngockhoale/ukit 3.0.9 → 3.0.11

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

@@ -42,6 +42,12 @@ export function useWebSocket(url, options = {}) {
   const RETRY_DELAY = options.retryDelay || 3000
   const connectionStatus = ref('initial') // 'initial', 'connecting', 'connected', 'disconnected', 'error'
   const lastError = ref(null)
+  // C80-12/13: pending retry timer + disposed flag. Both onerror and onclose
+  // call retryConnection for a single failure; without dedup that fires two
+  // parallel reconnect loops. Without storing the timer, a pending retry
+  // survives unmount and reconnects a zombie socket.
+  let retryTimer = null
+  let disposed = false
 
   // Debug logging function
   const debugLog = (type, message, data = null) => {
@@ -50,6 +56,7 @@ export function useWebSocket(url, options = {}) {
   }
 
   const connect = () => {
+    disposed = false
     if (!url) {
       debugLog('ERROR', 'WebSocket URL is required')
       error.value = 'WebSocket URL is required'
@@ -61,7 +68,7 @@ export function useWebSocket(url, options = {}) {
 
     try {
       socket.value = new WebSocket(url)
-      
+
       socket.value.onopen = () => {
         connectionStatus.value = 'connected'
         debugLog('SUCCESS', 'WebSocket connection opened successfully')
@@ -106,10 +113,16 @@ export function useWebSocket(url, options = {}) {
   }
 
   const retryConnection = () => {
+    if (disposed || retryTimer !== null) {
+      return
+    }
     if (retryCount.value < MAX_RETRIES) {
       retryCount.value++
       debugLog('INFO', `Retrying connection (${retryCount.value}/${MAX_RETRIES})...`)
-      setTimeout(connect, RETRY_DELAY)
+      retryTimer = setTimeout(() => {
+        retryTimer = null
+        connect()
+      }, RETRY_DELAY)
     } else {
       connectionStatus.value = 'error'
       debugLog('ERROR', 'Max retry attempts reached')
@@ -130,6 +143,11 @@ export function useWebSocket(url, options = {}) {
 
   onMounted(connect)
   onUnmounted(() => {
+    disposed = true
+    if (retryTimer !== null) {
+      clearTimeout(retryTimer)
+      retryTimer = null
+    }
     if (socket.value) {
       debugLog('INFO', 'Disconnecting WebSocket')
       socket.value.close()
@@ -143,6 +161,11 @@ export function useWebSocket(url, options = {}) {
   return {
     connect,
     disconnect: () => {
+      disposed = true
+      if (retryTimer !== null) {
+        clearTimeout(retryTimer)
+        retryTimer = null
+      }
       if (socket.value) {
         debugLog('INFO', 'Disconnecting WebSocket')
         socket.value.close()

package/template_project/.claude/skills/pptx/scripts/rearrange.py

@@ -155,8 +155,17 @@ def rearrange_presentation(template_path, output_path, slide_sequence):
         output_path: Path for output PPTX file
         slide_sequence: List of slide indices (0-based) to include
     """
-    # Copy template to preserve dimensions and theme
-    if template_path != output_path:
+    # Copy template to preserve dimensions and theme.
+    # C80-21: compare RESOLVED paths, not raw strings — "./a.pptx" vs "a.pptx"
+    # are the same file and shutil.copy2 onto itself raises SameFileError.
+    same_file = os.path.abspath(template_path) == os.path.abspath(output_path)
+    if not same_file:
+        if os.path.exists(output_path) and os.path.exists(template_path):
+            try:
+                same_file = os.path.samefile(template_path, output_path)
+            except OSError:
+                same_file = False
+    if not same_file:
         shutil.copy2(template_path, output_path)
         prs = Presentation(output_path)
     else:

package/template_project/.claude/skills/root-cause-tracing/find-polluter.sh

@@ -18,15 +18,30 @@ echo "🔍 Searching for test that creates: $POLLUTION_CHECK"
 echo "Test pattern: $TEST_PATTERN"
 echo ""
 
-# Get list of test files
-TEST_FILES=$(find . -path "$TEST_PATTERN" | sort)
-TOTAL=$(echo "$TEST_FILES" | wc -l | tr -d ' ')
+# Get list of test files.
+# C80-22: find -path has no '**' semantics — collapse runs of '*' so
+# 'src/**/*.test.ts' matches files at ANY depth (find's '*' already crosses
+# '/'), and expand '/**/' to also cover zero directory levels.
+FIND_PATTERN="${TEST_PATTERN//\*\*\/\*/*}"
+FIND_PATTERN="${FIND_PATTERN//\*\*\/\//*/}"
+FIND_PATTERN="${FIND_PATTERN//\/**\//}"
+FIND_PATTERN="${FIND_PATTERN//\*\*/*}"
+# find prints './'-prefixed paths; a pattern must match the WHOLE path.
+case "$FIND_PATTERN" in
+  ./*|/*|\**) ;;
+  *) FIND_PATTERN="./$FIND_PATTERN" ;;
+esac
+TEST_FILES=$(find . -path "$FIND_PATTERN" | sort)
+TOTAL=$(printf '%s\n' "$TEST_FILES" | grep -c . | tr -d ' ')
 
 echo "Found $TOTAL test files"
 echo ""
 
 COUNT=0
-for TEST_FILE in $TEST_FILES; do
+# C80-22: iterate line-wise — `for x in $files` splits on whitespace and
+# breaks test filenames containing spaces.
+while IFS= read -r TEST_FILE; do
+  [ -z "$TEST_FILE" ] && continue
   COUNT=$((COUNT + 1))
 
   # Skip if pollution already exists
@@ -56,7 +71,7 @@ for TEST_FILE in $TEST_FILES; do
     echo "  cat $TEST_FILE         # Review test code"
     exit 1
   fi
-done
+done <<< "$TEST_FILES"
 
 echo ""
 echo "✅ No polluter found - all tests clean!"

package/template_project/.claude/skills/webapp-testing/scripts/with_server.py

@@ -19,6 +19,9 @@ import socket
 import time
 import sys
 import argparse
+import os
+import signal
+
 
 def is_server_ready(port, timeout=30):
     """Wait for server to be ready by polling the port."""
@@ -65,12 +68,19 @@ def main():
         for i, server in enumerate(servers):
             print(f"Starting server {i+1}/{len(servers)}: {server['cmd']}")
 
-            # Use shell=True to support commands with cd and &&
+            # Use shell=True to support commands with cd and &&.
+            # C80-17: stdout/stderr go to the inherited terminal, NOT PIPE —
+            # a piped-but-undrained server deadlocks once it logs past the OS
+            # pipe buffer (~64KB) and is_server_ready then reports a bogus
+            # "failed to start" timeout.
+            # C80-18: start_new_session puts the shell + all its children in a
+            # dedicated process group so cleanup can signal the WHOLE tree —
+            # terminate() alone kills only the /bin/sh wrapper and orphans the
+            # real server (port stays bound for the next run).
             process = subprocess.Popen(
                 server['cmd'],
                 shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
+                start_new_session=(os.name == 'posix'),
             )
             server_processes.append(process)
 
@@ -93,14 +103,35 @@ def main():
         print(f"\nStopping {len(server_processes)} server(s)...")
         for i, process in enumerate(server_processes):
             try:
-                process.terminate()
+                _terminate_group(process)
                 process.wait(timeout=5)
             except subprocess.TimeoutExpired:
-                process.kill()
+                _kill_group(process)
                 process.wait()
             print(f"Server {i+1} stopped")
         print("All servers stopped")
 
 
 if __name__ == '__main__':
-    main()
+    main()
+
+def _terminate_group(process):
+    """SIGTERM the whole process group on POSIX; fall back to terminate()."""
+    if os.name == 'posix':
+        try:
+            os.killpg(process.pid, signal.SIGTERM)
+            return
+        except (ProcessLookupError, PermissionError):
+            return  # group already gone
+    process.terminate()
+
+
+def _kill_group(process):
+    """SIGKILL the whole process group on POSIX; fall back to kill()."""
+    if os.name == 'posix':
+        try:
+            os.killpg(process.pid, signal.SIGKILL)
+            return
+        except (ProcessLookupError, PermissionError):
+            return
+    process.kill()

package/template_project/.claude/ukit/index/cache-utils.mjs

@@ -60,25 +60,31 @@ export async function readRecentCacheEntry(
     ...entry,
     updatedAt: Date.now(),
   };
-  return withFileLock(cachePath, async () => {
-    const locked = await readRecentCache(cachePath, { maxEntries });
-    const lockedIndex = locked.entries.findIndex((lockedEntry) => lockedEntry.requestKey === requestKey);
-    if (lockedIndex < 0) {
-      return touchedEntry;
-    }
-    const lockedEntry = {
-      ...locked.entries[lockedIndex],
-      updatedAt: touchedEntry.updatedAt,
-    };
-    const entries = [
-      lockedEntry,
-      ...locked.entries.slice(0, lockedIndex),
-      ...locked.entries.slice(lockedIndex + 1),
-    ].slice(0, maxEntries);
-    const document = buildCacheDocument(entries, { maxEntries });
-    await writeCacheJson(cachePath, document);
-    return document.entries[0] ?? lockedEntry;
-  });
+  // A full/unwritable cache must never reject the read — degrade to the
+  // in-memory touched entry (same contract as token-utils readPromptCacheEntry).
+  try {
+    return await withFileLock(cachePath, async () => {
+      const locked = await readRecentCache(cachePath, { maxEntries });
+      const lockedIndex = locked.entries.findIndex((lockedEntry) => lockedEntry.requestKey === requestKey);
+      if (lockedIndex < 0) {
+        return touchedEntry;
+      }
+      const lockedEntry = {
+        ...locked.entries[lockedIndex],
+        updatedAt: touchedEntry.updatedAt,
+      };
+      const entries = [
+        lockedEntry,
+        ...locked.entries.slice(0, lockedIndex),
+        ...locked.entries.slice(lockedIndex + 1),
+      ].slice(0, maxEntries);
+      const document = buildCacheDocument(entries, { maxEntries });
+      await writeCacheJson(cachePath, document);
+      return document.entries[0] ?? lockedEntry;
+    });
+  } catch {
+    return touchedEntry;
+  }
 }
 
 export async function writeRecentCacheEntry(

package/template_project/.claude/ukit/index/impact-context.mjs

@@ -59,19 +59,22 @@ async function main() {
 }
 
 async function ensureFreshIndex(rootDir) {
-  const generatedAtMs = await getIndexArtifactGeneratedAt({ rootDir });
-  const stale = generatedAtMs === null
-    ? true
-    : await isIndexStale({
-        rootDir,
-        maxAgeMs: DEFAULT_INDEX_CACHE_MAX_AGE_MS,
-        now: Date.now(),
-        generatedAtMs,
-      });
-
-  if (stale) {
-    await buildCodeIndex({ rootDir });
+  if (typeof indexCore.ensureIndexFresh === 'function') {
+    return indexCore.ensureIndexFresh({ rootDir });
   }
+  const lastRefreshMs = await getIndexArtifactGeneratedAt({ rootDir });
+  const stale = lastRefreshMs === null
+    ? true
+    : typeof indexCore.isIndexStale === 'function'
+      ? await indexCore.isIndexStale({
+          rootDir,
+          maxAgeMs: DEFAULT_INDEX_CACHE_MAX_AGE_MS,
+          now: Date.now(),
+          generatedAtMs: lastRefreshMs,
+        })
+      : (Date.now() - lastRefreshMs) > DEFAULT_INDEX_CACHE_MAX_AGE_MS;
+  if (!stale) return;
+  await buildCodeIndex({ rootDir });
 }
 
 function printCompact(impact) {
@@ -119,4 +122,9 @@ function getRootDir(args) {
   return path.resolve(explicitRoot || process.cwd());
 }
 
-await main();
+try {
+  await main();
+} catch (error) {
+  console.error(error && error.message ? error.message : error);
+  process.exit(1);
+}

package/template_project/.claude/ukit/index/lib/index-core.mjs

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { spawnSync } from 'node:child_process';
+import { withFileLock } from '../../runtime/token-utils.mjs';
 
 // One wall-clock ceiling for the WHOLE discovery phase: both `git ls-files`
 // enumerations AND the non-git fallback walk share this single budget. Every
@@ -464,6 +465,20 @@ export async function buildCodeIndex({ rootDir = process.cwd(), changedFiles = n
   // artifact-graph phases above) must not replace any artifact either, so the
   // whole write block sits behind this gate.
   assertNotAborted(signal, 'publish');
+  // Invalidate the process-lifetime artifact caches BEFORE the first write:
+  // clearing only after all writes leaves a window where queued/concurrent
+  // reads in this process keep serving the pre-rebuild generation (C80-08).
+  const preservedRuntimeCaches = canReuseFilesArtifact
+    && canReuseAllParsedArtifacts
+    && canReuseTestsMap
+    && canReuseHotspots
+    && canReuseArchetypes
+    && canReuseRelations
+    && canReuseAnalogs;
+  if (!preservedRuntimeCaches) {
+    clearIndexArtifactCache(absoluteRoot);
+    RELATED_TEST_LOOKUP_CACHE.delete(absoluteRoot);
+  }
   await fs.mkdir(indexDir, { recursive: true });
   if (!canReuseFilesArtifact) {
     await writeArtifact(absoluteRoot, INDEX_ARTIFACTS.files, { schemaVersion: INDEX_SCHEMA_VERSION, generatedAt, items: fileRecords });
@@ -502,17 +517,6 @@ export async function buildCodeIndex({ rootDir = process.cwd(), changedFiles = n
       [INDEX_ARTIFACTS.relations]: relations.length,
     },
   });
-  const preservedRuntimeCaches = canReuseFilesArtifact
-    && canReuseAllParsedArtifacts
-    && canReuseTestsMap
-    && canReuseHotspots
-    && canReuseArchetypes
-    && canReuseRelations
-    && canReuseAnalogs;
-  if (!preservedRuntimeCaches) {
-    clearIndexArtifactCache(absoluteRoot);
-    RELATED_TEST_LOOKUP_CACHE.delete(absoluteRoot);
-  }
 
   return {
     indexDir,
@@ -694,6 +698,13 @@ async function resolveChangedHintUpdates(rootDir, changedPaths, previousRecordsB
     if (!isSafeContainedRelative(rootDir, relativePath)) {
       return null;
     }
+    // Hints under directories discovery never indexes are no-ops, not trust
+    // failures: `node_modules/`, `.cache/` and friends bypassed this lane and
+    // entered the index as phantom rows that kept the index perpetually stale.
+    // Same predicate as collectGitTrackedFiles.
+    if (relativePath.split('/').some((segment) => EXCLUDED_DIR_NAMES.has(segment))) {
+      continue;
+    }
 
     const absolutePath = path.join(rootDir, relativePath);
     let stat = null;
@@ -4319,8 +4330,8 @@ export async function resolveImpactContext({
     loadRelatedTestArtifacts({ rootDir: absoluteRoot }),
   ]);
 
-  const callItems = callsArtifact.items ?? [];
-  const importItems = importsArtifact.items ?? [];
+  const callItems = safeItems(callsArtifact);
+  const importItems = safeItems(importsArtifact);
   const risk = classifyImpactRisk(normalizedChangedFiles);
   const mirrorCounterparts = findMirrorCounterparts(normalizedChangedFiles).slice(0, budget.maxMirrors);
   const changedFileSet = new Set(normalizedChangedFiles);
@@ -4358,7 +4369,7 @@ export async function resolveImpactContext({
   // through the same machinery the index builder uses; relative specifiers keep
   // the candidate-list match so a changed file absent from files.json (e.g. a
   // brand-new file) still counts.
-  const indexedFileSet = new Set((filesArtifact.items ?? []).map((item) => item.filePath));
+  const indexedFileSet = new Set(safeItems(filesArtifact).map((item) => item.filePath));
   const importAliasContext = importsNeedAliasContext(importItems)
     ? await loadImportAliasContext({ rootDir: absoluteRoot }).catch(() => null)
     : null;
@@ -4528,3 +4539,74 @@ export async function isIndexStale({
   const { stale } = await evaluateIndexStaleness({ rootDir, maxAgeMs, now, generatedAtMs, enumerateForSnapshot: false, signal, deadlineMs });
   return stale;
 }
+
+/**
+ * Shared freshness gate for all index CLIs/hooks. The stale check + rebuild runs
+ * inside a cross-process file lock (withAsyncLock under withFileLock): without
+ * it, two processes that both observe a stale index enumerate the repository
+ * twice and interleave writeArtifact renames, so a reader starting mid-race can
+ * consume files.json from build A and symbols.json from build B. Inside the
+ * lock the staleness check re-runs, so the second contender becomes a no-op.
+ * Fail-closed lock policy: if the lock cannot be acquired (an extreme hold), we
+ * return the prior timestamp and the caller serves the existing index rather
+ * than building unlocked.
+ */
+export async function ensureIndexFresh({
+  rootDir = process.cwd(),
+  maxAgeMs = DEFAULT_INDEX_CACHE_MAX_AGE_MS,
+  logPrefix = null,
+  signal = null,
+  deadlineMs = null,
+  discoverySnapshot = null,
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+  const discoveryOptions = {
+    ...(signal ? { signal } : {}),
+    ...(Number.isFinite(deadlineMs) && deadlineMs > 0 ? { deadlineMs } : {}),
+  };
+  const lastRefreshMs = await getIndexArtifactGeneratedAt({ rootDir: absoluteRoot });
+  const stale = lastRefreshMs === null
+    || (await isIndexStale({
+      rootDir: absoluteRoot,
+      maxAgeMs,
+      now: Date.now(),
+      generatedAtMs: lastRefreshMs,
+      ...discoveryOptions,
+    }));
+
+  if (!stale) {
+    return lastRefreshMs;
+  }
+
+  const lockPath = `${getIndexDir(absoluteRoot)}/index-build.lock`;
+  const result = await withFileLock(lockPath, async () => {
+    const lockedRefreshMs = await getIndexArtifactGeneratedAt({ rootDir: absoluteRoot });
+    const lockedStale = lockedRefreshMs === null
+      || (await isIndexStale({
+        rootDir: absoluteRoot,
+        maxAgeMs,
+        now: Date.now(),
+        generatedAtMs: lockedRefreshMs,
+        ...discoveryOptions,
+      }));
+    if (!lockedStale) {
+      return { refreshed: false, generatedAtMs: lockedRefreshMs };
+    }
+    const summary = await buildCodeIndex({ rootDir: absoluteRoot, ...discoveryOptions, discoverySnapshot });
+    return { refreshed: true, summary, generatedAtMs: summary?.generatedAtMs ?? Date.now() };
+  });
+
+  if (result === undefined) {
+    // Lock wait expired — serve the previous generation rather than build
+    // unlocked. The drop is journaled by withFileLock.
+    return lastRefreshMs;
+  }
+  if (result.refreshed && logPrefix) {
+    if (lastRefreshMs !== null) {
+      console.log(`[ukit:${logPrefix}] stale index refreshed (last=${new Date(lastRefreshMs).toISOString()})`);
+    } else {
+      console.log(`[ukit:${logPrefix}] stale index refreshed (no previous cache timestamp)`);
+    }
+  }
+  return result.generatedAtMs ?? lastRefreshMs;
+}

package/template_project/.claude/ukit/index/query-index.mjs

@@ -29,7 +29,7 @@ const query = collectPositionalArgs(args, ['--root', '--limit']);
 if (!query) {
   console.error('Usage: node .claude/ukit/index/query-index.mjs "<error|symbol|path>"');
   process.exitCode = 1;
-} else {
+} else try {
   const indexGeneratedAtMs = await ensureFreshIndex({ rootDir, logPrefix: 'index:query' });
   const effectiveLimit = Number.isNaN(limit) ? 5 : limit;
   const cachePath = path.join(rootDir, '.claude', 'ukit', 'query-index-cache.json');
@@ -79,6 +79,11 @@ if (!query) {
   }
 }
 
+catch (error) {
+  console.error(error && error.message ? error.message : error);
+  process.exit(1);
+}
+
 async function printOutlineForFile(root, filePath) {
   if (typeof getFileOutline !== 'function') {
     return;
@@ -106,6 +111,10 @@ async function printOutlineForFile(root, filePath) {
 }
 
 async function ensureFreshIndex({ rootDir, logPrefix }) {
+  if (typeof indexCore.ensureIndexFresh === 'function') {
+    return indexCore.ensureIndexFresh({ rootDir, logPrefix });
+  }
+  // Fallback for stubbed/legacy index-cores (tests inject minimal modules).
   const lastRefreshMs = await getIndexArtifactGeneratedAt({ rootDir });
   const stale = lastRefreshMs === null
     ? true
@@ -117,17 +126,10 @@ async function ensureFreshIndex({ rootDir, logPrefix }) {
           generatedAtMs: lastRefreshMs,
         })
       : (Date.now() - lastRefreshMs) > DEFAULT_INDEX_CACHE_MAX_AGE_MS;
-
-  if (!stale) {
-    return lastRefreshMs;
-  }
-
+  if (!stale) return lastRefreshMs;
   const summary = await buildCodeIndex({ rootDir });
-  if (lastRefreshMs !== null) {
-    console.log(`[ukit:${logPrefix}] stale index refreshed (last=${new Date(lastRefreshMs).toISOString()})`);
-  } else {
-    console.log(`[ukit:${logPrefix}] stale index refreshed (no previous cache timestamp)`);
-  }
+  // Prefer the build's own generatedAtMs; only re-read when the stubbed
+  // build didn't report one (keeps generatedAt call count at 1).
   return Number.isFinite(summary?.generatedAtMs)
     ? summary.generatedAtMs
     : getIndexArtifactGeneratedAt({ rootDir });

package/template_project/.claude/ukit/index/resolve-context.mjs

@@ -31,7 +31,7 @@ const effectiveIntent = deriveHelperIntent({ intent, targetFile });
 if (!intent && !targetFile) {
   console.error('Usage: node .claude/ukit/index/resolve-context.mjs "<intent>" [--target <file>] [--type trivial|simple|non-trivial]');
   process.exitCode = 1;
-} else {
+} else try {
   const indexGeneratedAtMs = await ensureFreshIndex({
     rootDir,
     logPrefix: 'context',
@@ -64,7 +64,15 @@ if (!intent && !targetFile) {
   await printContextResult(result, { rootDir, showOutline });
 }
 
+catch (error) {
+  console.error(error && error.message ? error.message : error);
+  process.exit(1);
+}
+
 async function ensureFreshIndex({ rootDir, logPrefix }) {
+  if (typeof indexCore.ensureIndexFresh === 'function') {
+    return indexCore.ensureIndexFresh({ rootDir, logPrefix });
+  }
   const lastRefreshMs = await getIndexArtifactGeneratedAt({ rootDir });
   const stale = lastRefreshMs === null
     ? true
@@ -76,17 +84,10 @@ async function ensureFreshIndex({ rootDir, logPrefix }) {
           generatedAtMs: lastRefreshMs,
         })
       : (Date.now() - lastRefreshMs) > DEFAULT_INDEX_CACHE_MAX_AGE_MS;
-
-  if (!stale) {
-    return lastRefreshMs;
-  }
-
+  if (!stale) return lastRefreshMs;
   const summary = await buildCodeIndex({ rootDir });
-  if (lastRefreshMs !== null) {
-    console.log(`[ukit:${logPrefix}] stale index refreshed (last=${new Date(lastRefreshMs).toISOString()})`);
-  } else {
-    console.log(`[ukit:${logPrefix}] stale index refreshed (no previous cache timestamp)`);
-  }
+  // Prefer the build's own generatedAtMs; only re-read when the stubbed
+  // build didn't report one (keeps generatedAt call count at 1).
   return Number.isFinite(summary?.generatedAtMs)
     ? summary.generatedAtMs
     : getIndexArtifactGeneratedAt({ rootDir });

package/template_project/.claude/ukit/index/route-task.mjs

@@ -1599,10 +1599,16 @@ async function main() {
   }
 
   if (cachedRouteState && canPersistCachedRouteState) {
-    await readRecentCacheEntry(routeCachePath, requestKey, {
-      maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
-      touch: true,
-    });
+    // Advisory hit-count touch — an EACCES/ENOSPC under the lock must never
+    // lose the cached route; skip the touch and keep going.
+    try {
+      await readRecentCacheEntry(routeCachePath, requestKey, {
+        maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+        touch: true,
+      });
+    } catch (error) {
+      console.error(`route-task: state persist degraded — ${error?.message ?? error}`);
+    }
   }
 
   if (cachedRouteState) {
@@ -1646,10 +1652,16 @@ async function main() {
     };
     sharedState.fingerprint = buildRouteStateFingerprint(sharedState);
     if (canPersistCachedRouteState) {
-      await persistSharedRouteState(sharedStatePath, sharedState);
-      await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
-        state: sharedState,
-      }));
+      // Advisory persistence — an EACCES/ENOSPC under the lock must never lose
+      // the printed route; degrade to stderr and print anyway.
+      try {
+        await persistSharedRouteState(sharedStatePath, sharedState);
+        await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+          state: sharedState,
+        }));
+      } catch (error) {
+        console.error(`route-task: state persist degraded — ${error?.message ?? error}`);
+      }
     }
     printRouteState(sharedState);
     return;
@@ -1693,23 +1705,31 @@ async function main() {
     sessionId,
   });
   if (canPersistRouteState) {
-    await persistSharedRouteState(sharedStatePath, sharedState);
-    await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
-      route,
-      state: sharedState,
-    }));
-    await writeRecentCacheEntry(routeCachePath, compactRouteCacheState(sharedState), {
-      maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
-    });
+    // Advisory persistence — an EACCES/ENOSPC under the lock must never lose
+    // the printed route; degrade to stderr and print anyway.
+    try {
+      await persistSharedRouteState(sharedStatePath, sharedState);
+      await appendRouteAuditEntry(routeAuditPath, buildRouteAuditEntry({
+        route,
+        state: sharedState,
+      }));
+      await writeRecentCacheEntry(routeCachePath, compactRouteCacheState(sharedState), {
+        maxEntries: DEFAULT_RECENT_CACHE_MAX_ENTRIES,
+      });
+    } catch (error) {
+      console.error(`route-task: state persist degraded — ${error?.message ?? error}`);
+    }
   }
 
   printRouteState(sharedState);
 }
 
 async function ensureFreshIndex({ rootDir, logPrefix, signal = null, deadlineMs = null, discoverySnapshot = null } = {}) {
-  // TASK-030: the stale check and the rebuild are the router's heaviest unchanged-input
-  // reads (one full repository enumeration each), so both accept the caller's top-level
-  // deadline/signal. Omitted (main()'s CLI path) keeps the index-core defaults.
+  if (typeof indexCore.ensureIndexFresh === 'function') {
+    // Cross-process build lock + staleness re-check live in index-core (C80-07).
+    return indexCore.ensureIndexFresh({ rootDir, logPrefix, signal, deadlineMs, discoverySnapshot });
+  }
+  // Fallback for stubbed/legacy index-cores (tests inject minimal modules).
   const discoveryOptions = {
     ...(signal ? { signal } : {}),
     ...(Number.isFinite(deadlineMs) && deadlineMs > 0 ? { deadlineMs } : {}),
@@ -1726,11 +1746,7 @@ async function ensureFreshIndex({ rootDir, logPrefix, signal = null, deadlineMs
           ...discoveryOptions,
         })
       : (Date.now() - lastRefreshMs) > DEFAULT_INDEX_CACHE_MAX_AGE_MS;
-
-  if (!stale) {
-    return lastRefreshMs;
-  }
-
+  if (!stale) return lastRefreshMs;
   const summary = await buildCodeIndex({ rootDir, ...discoveryOptions, discoverySnapshot });
   if (lastRefreshMs !== null) {
     console.log(`[ukit:${logPrefix}] stale index refreshed (last=${new Date(lastRefreshMs).toISOString()})`);
@@ -6009,5 +6025,8 @@ function isDirectCliInvocation() {
 }
 
 if (isDirectCliInvocation()) {
-  await main();
+  main().catch((error) => {
+    console.error(`route-task: ${error?.message ?? error}`);
+    process.exitCode = 1;
+  });
 }