@ngockhoale/ukit 3.4.67 → 3.4.68

package/template_project/.claude/ukit/index/plan-count.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// plan-count.mjs — CR-11: an owner-stated plan count is delivered as that many real plan
+// units, never as group labels inside one PLAN.md.
+//
+// A "real plan unit" is a directory carrying its own PLAN.md **and** INDEX.md, where both
+// files are non-empty regular files with a recognisable markdown heading (`# …`):
+//   - the audited root itself (canonical `docs/AI_HANDOFF/` or a queued root) counts once
+//     when it has both files;
+//   - each `queued/<slug>/` under it with both files counts once. Units are deduplicated by
+//     realpath, so a symlinked alias of an already-counted directory is not a second unit.
+// A queued dir with only some of the files (or files that are empty / headingless) is
+// reported as incomplete and never satisfies the count.
+//
+// Usage:
+//   node .claude/ukit/index/plan-count.mjs <handoff-root> <expected-count>
+//
+// Output:
+//   `PLAN_COUNT: ok (<found>/<expected>)` or
+//   `plan count: <found> real plan units found, owner stated <expected>` plus one
+//   `plan unit incomplete -> <dir>` line per queued dir that has only some of the files.
+//   Exit 0 = satisfied, 1 = count not met, 2 = usage.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+function isDirectRun() {
+  try {
+    return Boolean(process.argv[1]) && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+const HEADING = /^#{1,6}\s+\S/m;
+
+// A recognisable planning file: regular (not a symlink), non-empty, carries a heading.
+function isRealPlanFile(file) {
+  try {
+    const st = fs.lstatSync(file);
+    if (!st.isFile() || st.size === 0) return false;
+    return HEADING.test(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return false;
+  }
+}
+
+function hasAnyPlanFile(dir) {
+  return fs.existsSync(path.join(dir, 'PLAN.md')) || fs.existsSync(path.join(dir, 'INDEX.md'));
+}
+
+function isPlanUnit(dir) {
+  return isRealPlanFile(path.join(dir, 'PLAN.md')) && isRealPlanFile(path.join(dir, 'INDEX.md'));
+}
+
+function main() {
+  const root = process.argv[2];
+  const expectedRaw = process.argv[3];
+  const expected = Number(expectedRaw);
+  if (!root || !Number.isInteger(expected) || expected < 1) {
+    console.log('PLAN_COUNT: usage error — expected `<root> <positive-integer>`');
+    process.exit(2);
+  }
+
+  const units = [];
+  const seen = new Set();
+  const incomplete = [];
+  const addUnit = (dir) => {
+    let real;
+    try {
+      real = fs.realpathSync(dir);
+    } catch {
+      return;
+    }
+    if (seen.has(real)) return;
+    seen.add(real);
+    units.push(dir);
+  };
+
+  if (isPlanUnit(root)) addUnit(root);
+
+  let slugs;
+  try {
+    slugs = fs.readdirSync(path.join(root, 'queued'));
+  } catch {
+    slugs = [];
+  }
+  for (const slug of slugs.sort()) {
+    const dir = path.join(root, 'queued', slug);
+    let stat;
+    try {
+      stat = fs.statSync(dir); // follows symlinks: a symlinked unit dir is still a directory
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    if (isPlanUnit(dir)) addUnit(dir);
+    else if (hasAnyPlanFile(dir)) incomplete.push(dir);
+  }
+
+  for (const dir of incomplete) {
+    console.log(`plan unit incomplete -> ${dir} (a real unit needs its own non-empty PLAN.md and INDEX.md with a heading)`);
+  }
+  if (units.length < expected) {
+    console.log(`plan count: ${units.length} real plan units found, owner stated ${expected}`);
+    process.exit(1);
+  }
+  console.log(`PLAN_COUNT: ok (${units.length}/${expected})`);
+  process.exit(0);
+}
+
+if (isDirectRun()) {
+  main();
+}

package/template_project/.claude/ukit/index/ready-gate.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// ready-gate.mjs — CR-06: `ready` is a verdict, verified from disk, never from memory.
+//
+// Verifies that every task currently marked `ready` (task file `- Status:` line and/or the
+// INDEX.md row) has BOTH gates recorded on disk:
+//   1. a tool-written `Validator: ok <YYYY-MM-DD>` (or `Validator: dismissed <YYYY-MM-DD> — reason`)
+//      line inside the task's `## Discussion` section — a verdict held only in session
+//      memory does not count (compaction-safe);
+//   2. `PLAN_REVIEW: Approved` in the root's PLAN.md.
+// It also flags index/task status mismatches (one side flipped, the other did not).
+//
+// Usage:
+//   node .claude/ukit/index/ready-gate.mjs [handoff-root]      (default: docs/AI_HANDOFF)
+//
+// Output:
+//   `READY_GATE: ok` when every ready task is evidenced;
+//   otherwise one named `tasks not ready: <gate> -> <TASK-ID>` / `index/task mismatch -> <TASK-ID>`
+//   line per problem. Exit 0 = gates pass, exit 1 = gate failure (the flip step must stop),
+//   exit 2 = usage error.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+function isDirectRun() {
+  try {
+    return Boolean(process.argv[1]) && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
+const READY_STATUSES = new Set(['ready']);
+
+function readFileSafe(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function fileStatus(markdown) {
+  const m = /^-\s*Status:\s*`?([a-z_]+)`?/im.exec(String(markdown || ''));
+  return m ? m[1].toLowerCase() : null;
+}
+
+function discussionSection(markdown) {
+  const text = String(markdown || '');
+  const heading = /^##\s+Discussion\s*$/m.exec(text);
+  if (!heading) return null;
+  const rest = text.slice(heading.index + heading[0].length);
+  const boundary = /^##\s|^-{3,}\s*$/m.exec(rest);
+  return boundary ? rest.slice(0, boundary.index) : rest;
+}
+
+// Only the exact line shapes count, anchored to a line start (CR tolerated for CRLF files):
+//   - `Validator: ok <YYYY-MM-DD> ukit@<ver>` — written by task-budget-validator --record only;
+//   - `Validator: dismissed <YYYY-MM-DD> — <reason>` — the hand-written documented override.
+// Forged 2-field lines, headings, quoted prose and mid-sentence mentions do not satisfy the gate.
+const VALIDATOR_OK_LINE = /^Validator: ok \d{4}-\d{2}-\d{2} ukit@\S+[ \t\r]*$/m;
+const VALIDATOR_DISMISSED_LINE = /^Validator: dismissed \d{4}-\d{2}-\d{2} — \S.*?[ \t\r]*$/m;
+
+function hasValidatorRecord(markdown) {
+  const section = discussionSection(markdown);
+  if (section == null) return false;
+  return VALIDATOR_OK_LINE.test(section) || VALIDATOR_DISMISSED_LINE.test(section);
+}
+
+// INDEX.md is a markdown table whose header row locates the Status column; rows before the
+// table or with fewer cells are ignored (history prose, not rows).
+function indexStatuses(root) {
+  const raw = readFileSafe(path.join(root, 'INDEX.md'));
+  if (raw == null) return null;
+  const statuses = new Map();
+  const lines = raw.split('\n');
+  let statusCol = -1;
+  for (const line of lines) {
+    if (!line.startsWith('|')) continue;
+    const cells = line.split('|').slice(1, -1).map((c) => c.trim());
+    if (statusCol < 0) {
+      statusCol = cells.findIndex((c) => /^status$/i.test(c));
+      continue;
+    }
+    if (cells.length <= statusCol) continue;
+    const id = cells[0];
+    if (!/^TASK-/i.test(id)) continue;
+    statuses.set(id, cells[statusCol].toLowerCase());
+  }
+  return statuses;
+}
+
+function listTaskFiles(root) {
+  const tasksDir = path.join(root, 'tasks');
+  let entries;
+  try {
+    entries = fs.readdirSync(tasksDir);
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((f) => /^TASK-.*\.md$/i.test(f))
+    .map((f) => path.join(tasksDir, f))
+    .sort();
+}
+
+function main() {
+  const root = process.argv[2] || 'docs/AI_HANDOFF';
+  if (process.argv[3]) {
+    console.log(`READY_GATE: usage error — expected at most one root argument, got ${process.argv.length - 2}`);
+    process.exit(2);
+  }
+
+  const problems = [];
+  const indexStatusesMap = indexStatuses(root);
+  if (indexStatusesMap == null) {
+    console.log(`tasks not ready: index missing -> ${path.join(root, 'INDEX.md')}`);
+    process.exit(1);
+  }
+
+  const plan = readFileSafe(path.join(root, 'PLAN.md'));
+  // The planner footer line `PLAN_REVIEW: Approved by <reviewer model>` (line start only).
+  const planApproved = plan != null && /^PLAN_REVIEW: Approved by \S/m.test(plan);
+  let anyReady = false;
+
+  for (const file of listTaskFiles(root)) {
+    // Normalise the TASK- prefix so `task-001.md` and `TASK-001` name the same INDEX row.
+    const id = path.basename(file, '.md').replace(/^task-/i, 'TASK-');
+    const markdown = readFileSafe(file);
+    if (markdown == null) continue;
+    const status = fileStatus(markdown);
+    const indexed = indexStatusesMap.get(id);
+    indexStatusesMap.delete(id);
+
+    const claimedReady = READY_STATUSES.has(status) || READY_STATUSES.has(indexed);
+    if (!claimedReady) continue;
+    anyReady = true;
+
+    if (status !== indexed) {
+      problems.push(`index/task mismatch -> ${id} (file=${status || 'none'} index=${indexed || 'none'})`);
+    }
+    if (!hasValidatorRecord(markdown)) {
+      problems.push(`tasks not ready: validator -> ${id} (no recorded Validator: ok/dismissed line in ## Discussion)`);
+    }
+  }
+
+  // INDEX rows pointing at a task file that no longer exists: a ready row without its file
+  // is unverifiable evidence.
+  for (const [id, status] of indexStatusesMap) {
+    if (READY_STATUSES.has(status)) {
+      problems.push(`index/task mismatch -> ${id} (index=ready, task file missing)`);
+    }
+  }
+
+  if (anyReady && !planApproved) {
+    problems.push('tasks not ready: plan review (PLAN.md has no PLAN_REVIEW: Approved)');
+  }
+
+  if (problems.length > 0) {
+    for (const p of problems.sort()) console.log(p);
+    process.exit(1);
+  }
+  console.log('READY_GATE: ok');
+  process.exit(0);
+}
+
+if (isDirectRun()) {
+  main();
+}

package/template_project/.claude/ukit/index/reset-auto-permissions.mjs

@@ -7,9 +7,136 @@ function parseArgs(argv) {
   return {
     dryRun: argv.includes('--dry-run'),
     quiet: argv.includes('--quiet'),
+    sanitize: argv.includes('--sanitize'),
   };
 }
 
+// LA-02: the sanitizer removes ONLY rules that satisfy BOTH gates:
+//   (a) the rule token is in the SAME denylist the auto-allow hook enforces,
+//       and (b) the rule has proven UKit provenance: present in managedRules
+//       AND (record.added === true OR an audit-log auto_add event).
+// The denylist is parsed out of auto-allow-bash.sh (the marked
+// UKIT:AUTO-ALLOW:DENYLIST block) so hook and sanitizer share ONE definition.
+const DENYLIST_BEGIN_MARKER = 'UKIT:AUTO-ALLOW:DENYLIST:BEGIN';
+const DENYLIST_END_MARKER = 'UKIT:AUTO-ALLOW:DENYLIST:END';
+
+function hookPathForScript() {
+  return path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    '..',
+    '..',
+    'hooks',
+    'auto-allow-bash.sh',
+  );
+}
+
+async function loadHookDenyTokens() {
+  const hookPath = hookPathForScript();
+  let source;
+  try {
+    source = await fs.readFile(hookPath, 'utf8');
+  } catch {
+    throw new Error(
+      `auto-allow hook not found (${hookPath}) — refusing to sanitize without the shared denylist`,
+    );
+  }
+  const start = source.indexOf(DENYLIST_BEGIN_MARKER);
+  const end = source.indexOf(DENYLIST_END_MARKER);
+  if (start === -1 || end === -1 || end < start) {
+    throw new Error(
+      `${DENYLIST_BEGIN_MARKER} block not found in auto-allow-bash.sh — refusing to sanitize`,
+    );
+  }
+  const block = source.slice(start, end);
+  const tokens = new Set();
+  const assignment = /^UKIT_DENY_[A-Z_]+='([^']*)'$/gm;
+  let match;
+  while ((match = assignment.exec(block)) !== null) {
+    for (const token of match[1].split(/\s+/)) {
+      if (token) tokens.add(token);
+    }
+  }
+  if (tokens.size === 0) {
+    throw new Error('auto-allow denylist block parsed as empty — refusing to sanitize');
+  }
+  return tokens;
+}
+
+// The audit log rotates, so an absent/unreadable file simply yields no
+// audit-side proof; record.added === true remains the other provenance path.
+async function loadAuditAutoAddRules(auditPath) {
+  let raw;
+  try {
+    raw = await fs.readFile(auditPath, 'utf8');
+  } catch {
+    return new Set();
+  }
+  const rules = new Set();
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const event = JSON.parse(line);
+      if (event?.event === 'auto_add' && typeof event.rule === 'string') {
+        rules.add(event.rule);
+      }
+    } catch {
+      // Unparseable lines carry no proof — skipped, never fatal.
+    }
+  }
+  return rules;
+}
+
+// Classify each allow rule as REMOVE (both gates pass) or SKIP (with reason).
+function classifyAllowRules({ allow, managedRules, auditRules, denyTokens }) {
+  const removals = [];
+  const skips = [];
+  for (const rule of allow) {
+    const parsed = /^Bash\(([^:]+):\*\)$/.exec(String(rule));
+    if (!parsed) {
+      skips.push({ rule, reason: 'not a simple Bash(<token>:*) rule — left in place' });
+      continue;
+    }
+    const token = parsed[1];
+    const base = token.includes('/') ? token.slice(token.lastIndexOf('/') + 1) : token;
+    if (!denyTokens.has(base)) {
+      skips.push({ rule, reason: 'not a UKit auto-allow denylist token — left in place' });
+      continue;
+    }
+    const meta = managedRules[rule];
+    const hasManaged = Boolean(meta) && typeof meta === 'object';
+    const proven = hasManaged && (meta.added === true || auditRules.has(rule));
+    if (proven) {
+      removals.push({
+        rule,
+        via: meta.added === true ? 'managedRules added:true' : 'audit-log auto_add',
+      });
+    } else {
+      skips.push({
+        rule,
+        reason:
+          'unproven, left in place — no managedRules record with added:true and no audit-log '
+          + 'auto_add event. NOTE: rules minted before UKit recorded provenance cannot be '
+          + 'proven; run the full reset (this script without --sanitize) to clear ALL '
+          + 'managed rules.',
+      });
+    }
+  }
+  return { removals, skips };
+}
+
+// Preserve the original file's indent and trailing-newline style; JSON.parse
+// already preserves key order, so stringify only replaces the removed array
+// entries.
+function serializeLike(originalText, value) {
+  if (typeof originalText !== 'string') {
+    return JSON.stringify(value, null, 2) + '\n';
+  }
+  const indentMatch = /^[ \t]+/m.exec(originalText);
+  const indent = indentMatch ? Math.min(indentMatch[0].length, 10) : 2;
+  const trailing = originalText.endsWith('\n') ? '\n' : '';
+  return JSON.stringify(value, null, indent) + trailing;
+}
+
 // W3-03 fail-closed read: a state file that exists but will not parse must
 // abort the reset — the previous `{}` fallback let a corrupt/JSONC
 // settings.local.json be rewritten as an empty object, wiping the whole allow
@@ -30,12 +157,14 @@ async function readJson(filePath, fallback) {
 
 // Same atomic shape as the auto-allow hook's writeJsonAtomic: tmp + rename so
 // readers (Claude Code re-parses settings.local.json to grant permissions)
-// see old-or-new, never a torn file.
-async function writeJsonAtomic(filePath, value) {
+// see old-or-new, never a torn file. `text` (optional) overrides the default
+// 2-space serialization — the sanitizer passes serializeLike(...) output to
+// preserve the file's original indent and key order.
+async function writeJsonAtomic(filePath, value, text) {
   await fs.mkdir(path.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`;
   try {
-    await fs.writeFile(tempPath, JSON.stringify(value, null, 2) + '\n');
+    await fs.writeFile(tempPath, typeof text === 'string' ? text : JSON.stringify(value, null, 2) + '\n');
     await fs.rename(tempPath, filePath);
   } catch (error) {
     try {
@@ -118,9 +247,169 @@ async function applyReset({ settingsLocalPath, usagePath, auditPath }) {
   return outcome.value;
 }
 
+// LA-02 sanitizer. Reports every decision; writes settings.local.json ONLY
+// when at least one proven denylist rule is removed, so untouched state stays
+// byte-identical. Dry-run lists planned removals and writes nothing.
+function reportSanitizePlan({ mode, removals, skips }) {
+  if (removals.length === 0) {
+    console.log('[UKit] Sanitize: no proven UKit-minted denylist rule(s) to remove.');
+  } else {
+    console.log(
+      `[UKit] Sanitize: ${mode} ${removals.length} auto-minted denylist rule(s) `
+      + 'from .claude/settings.local.json.',
+    );
+    console.log(`${mode === 'Would remove' ? 'Would remove' : 'Removed'}:`);
+    for (const { rule, via } of removals) {
+      console.log(`- ${rule} (provenance: ${via})`);
+    }
+  }
+  if (skips.length > 0) {
+    console.log('Kept (skipped):');
+    for (const { rule, reason } of skips) {
+      console.log(`- ${rule}: ${reason}`);
+    }
+  }
+}
+
+async function sanitizePlanFromState({ settings, usage, auditPath, denyTokens }) {
+  const auditRules = await loadAuditAutoAddRules(auditPath);
+  const allow = Array.isArray(settings?.permissions?.allow) ? settings.permissions.allow : [];
+  const managedRules =
+    usage?.managedRules && typeof usage.managedRules === 'object' ? usage.managedRules : {};
+  return classifyAllowRules({ allow, managedRules, auditRules, denyTokens });
+}
+
+async function applySanitize({ settingsLocalPath, usagePath, auditPath, denyTokens }) {
+  const lockModulePath = path.join(runtimeDirForScript(), 'async-lock.mjs');
+  let lockModule = null;
+  try {
+    lockModule = await import(pathToFileURL(lockModulePath).href);
+  } catch {
+    lockModule = null;
+  }
+  if (!lockModule || typeof lockModule.withAsyncLock !== 'function') {
+    throw new Error(
+      'async-lock.mjs is unavailable — refusing to write permission state unlocked (degraded install)',
+    );
+  }
+  await fs.mkdir(path.dirname(usagePath), { recursive: true });
+
+  const outcome = await lockModule.withAsyncLock(usagePath, {}, async () => {
+    // Re-read BOTH state files inside the critical section — a racing
+    // hook write may have landed between preflight and lock acquisition.
+    const settingsState = await readJson(settingsLocalPath, {});
+    if (settingsState.corrupt) {
+      throw new Error(
+        `settings.local.json exists but is not valid JSON (${settingsLocalPath}) — refusing to overwrite it`,
+      );
+    }
+    const usageState = await readJson(usagePath, {});
+    if (usageState.corrupt) {
+      throw new Error(
+        `permission-usage.json exists but is not valid JSON (${usagePath}) — refusing to guess managed rules`,
+      );
+    }
+    const settings = settingsState.value && typeof settingsState.value === 'object' ? settingsState.value : {};
+    const usage = usageState.value && typeof usageState.value === 'object' ? usageState.value : {};
+
+    const { removals, skips } = await sanitizePlanFromState({ settings, usage, auditPath, denyTokens });
+    if (removals.length === 0) {
+      return { removals, skips, changed: false };
+    }
+
+    const removalSet = new Set(removals.map((entry) => entry.rule));
+    settings.permissions =
+      settings.permissions && typeof settings.permissions === 'object' ? settings.permissions : {};
+    settings.permissions.allow = (Array.isArray(settings.permissions.allow)
+      ? settings.permissions.allow
+      : []
+    ).filter((rule) => !removalSet.has(rule));
+
+    let originalText = null;
+    try {
+      originalText = await fs.readFile(settingsLocalPath, 'utf8');
+    } catch {
+      originalText = null;
+    }
+    await fs.mkdir(path.dirname(settingsLocalPath), { recursive: true });
+    await writeJsonAtomic(settingsLocalPath, settings, serializeLike(originalText, settings));
+
+    const managedRules =
+      usage.managedRules && typeof usage.managedRules === 'object' ? usage.managedRules : {};
+    for (const { rule } of removals) {
+      delete managedRules[rule];
+    }
+    usage.lastSanitizedAt = new Date().toISOString();
+    await writeJsonAtomic(usagePath, usage);
+
+    const lines = removals
+      .map(({ rule, via }) =>
+        JSON.stringify({ ts: new Date().toISOString(), event: 'sanitize_remove', rule, via }))
+      .join('\n');
+    await fs.mkdir(path.dirname(auditPath), { recursive: true });
+    await fs.appendFile(auditPath, lines + '\n', 'utf8');
+
+    return { removals, skips, changed: true };
+  });
+
+  if (!outcome.ok) {
+    // Fail closed (TASK-028 policy): a contended lock means a hook write is in
+    // flight — never write permission state unlocked. Nothing was mutated.
+    throw new Error(
+      `could not acquire the permission-state lock (${outcome.reason}) — sanitize aborted, nothing was changed`,
+    );
+  }
+  return outcome.value;
+}
+
+async function runSanitize({ rootDir, dryRun, quiet }) {
+  // Fail closed BEFORE any state is touched: without the shared denylist the
+  // sanitizer must not guess what is removable.
+  const denyTokens = await loadHookDenyTokens();
+
+  const settingsLocalPath = path.join(rootDir, '.claude', 'settings.local.json');
+  const usagePath = path.join(rootDir, '.claude', 'ukit', 'permission-usage.json');
+  const auditPath = path.join(rootDir, '.claude', 'ukit', 'permission-audit.log');
+
+  if (dryRun) {
+    // Preflight reads for the report only; nothing is written in dry-run.
+    const settingsState = await readJson(settingsLocalPath, {});
+    if (settingsState.corrupt) {
+      throw new Error(
+        `settings.local.json exists but is not valid JSON (${settingsLocalPath}) — refusing to plan against it`,
+      );
+    }
+    const usageState = await readJson(usagePath, {});
+    if (usageState.corrupt) {
+      throw new Error(
+        `permission-usage.json exists but is not valid JSON (${usagePath}) — refusing to guess managed rules`,
+      );
+    }
+    const { removals, skips } = await sanitizePlanFromState({
+      settings: settingsState.value,
+      usage: usageState.value,
+      auditPath,
+      denyTokens,
+    });
+    if (!quiet) {
+      reportSanitizePlan({ mode: 'Would remove', removals, skips });
+    }
+    return;
+  }
+
+  const { removals, skips } = await applySanitize({ settingsLocalPath, usagePath, auditPath, denyTokens });
+  if (!quiet) {
+    reportSanitizePlan({ mode: 'Removed', removals, skips });
+  }
+}
+
 async function main() {
-  const { dryRun, quiet } = parseArgs(process.argv.slice(2));
+  const { dryRun, quiet, sanitize } = parseArgs(process.argv.slice(2));
   const rootDir = process.cwd();
+  if (sanitize) {
+    await runSanitize({ rootDir, dryRun, quiet });
+    return;
+  }
   const settingsLocalPath = path.join(rootDir, '.claude', 'settings.local.json');
   const usagePath = path.join(rootDir, '.claude', 'ukit', 'permission-usage.json');
   const auditPath = path.join(rootDir, '.claude', 'ukit', 'permission-audit.log');