@codacy/verity-cli 0.25.0-experimental.ed0c319 → 0.26.0-experimental.d7dfc00

package/bin/verity.js

@@ -11216,8 +11216,63 @@ function registerAuthCommands(program2) {
 }
 
 // src/lib/hooks.ts
+var import_promises5 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+
+// src/lib/json-file.ts
 var import_promises4 = require("node:fs/promises");
 var import_node_path4 = require("node:path");
+function jsonSemanticEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return a === b;
+  }
+  const aIsArr = Array.isArray(a);
+  const bIsArr = Array.isArray(b);
+  if (aIsArr || bIsArr) {
+    if (!aIsArr || !bIsArr || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!jsonSemanticEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const ao = a;
+  const bo = b;
+  const aKeys = Object.keys(ao).filter((k) => ao[k] !== void 0);
+  const bKeys = Object.keys(bo).filter((k) => bo[k] !== void 0);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const k of aKeys) {
+    if (bo[k] === void 0) return false;
+    if (!jsonSemanticEqual(ao[k], bo[k])) return false;
+  }
+  return true;
+}
+function detectJsonIndent(raw) {
+  const m = raw.match(/\n([ \t]+)\S/);
+  return m ? m[1] : 2;
+}
+async function writeJsonFilePreservingStyle(file, value) {
+  let currentRaw = null;
+  try {
+    currentRaw = await (0, import_promises4.readFile)(file, "utf-8");
+  } catch {
+    currentRaw = null;
+  }
+  if (currentRaw !== null) {
+    try {
+      if (jsonSemanticEqual(JSON.parse(currentRaw), value)) return false;
+    } catch {
+    }
+  }
+  const indent = currentRaw !== null ? detectJsonIndent(currentRaw) : 2;
+  const next = JSON.stringify(value, null, indent) + "\n";
+  if (next === currentRaw) return false;
+  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(file), { recursive: true });
+  await (0, import_promises4.writeFile)(file, next);
+  return true;
+}
+
+// src/lib/hooks.ts
 var VERITY_STOP_HOOK = {
   type: "command",
   command: "verity analyze",
@@ -11295,7 +11350,7 @@ function globalSettingsFile() {
 }
 async function readSettings() {
   try {
-    const content = await (0, import_promises4.readFile)(CLAUDE_SETTINGS_FILE, "utf-8");
+    const content = await (0, import_promises5.readFile)(CLAUDE_SETTINGS_FILE, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -11306,7 +11361,7 @@ async function readAllSettings() {
   const out = [];
   for (const f of files) {
     try {
-      out.push(JSON.parse(await (0, import_promises4.readFile)(f, "utf-8")));
+      out.push(JSON.parse(await (0, import_promises5.readFile)(f, "utf-8")));
     } catch {
     }
   }
@@ -11335,7 +11390,7 @@ async function checkExternalVerityHooks() {
   for (const f of [SETTINGS_LOCAL_FILE, globalSettingsFile()]) {
     let settings;
     try {
-      settings = JSON.parse(await (0, import_promises4.readFile)(f, "utf-8"));
+      settings = JSON.parse(await (0, import_promises5.readFile)(f, "utf-8"));
     } catch {
       continue;
     }
@@ -11369,20 +11424,17 @@ async function checkAllVerityHooksDetailed() {
   return { stop, intent, baseline, current: hasCurrent, legacyOnly: hasLegacy && !hasCurrent };
 }
 async function writeSettings(settings) {
-  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(CLAUDE_SETTINGS_FILE), { recursive: true });
-  await (0, import_promises4.writeFile)(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
+  await writeJsonFilePreservingStyle(CLAUDE_SETTINGS_FILE, settings);
 }
 async function readSettingsAt(root) {
   try {
-    return JSON.parse(await (0, import_promises4.readFile)((0, import_node_path4.join)(root, CLAUDE_SETTINGS_FILE), "utf-8"));
+    return JSON.parse(await (0, import_promises5.readFile)((0, import_node_path5.join)(root, CLAUDE_SETTINGS_FILE), "utf-8"));
   } catch {
     return {};
   }
 }
 async function writeSettingsAt(root, settings) {
-  const file = (0, import_node_path4.join)(root, CLAUDE_SETTINGS_FILE);
-  await (0, import_promises4.mkdir)((0, import_node_path4.dirname)(file), { recursive: true });
-  await (0, import_promises4.writeFile)(file, JSON.stringify(settings, null, 2) + "\n");
+  await writeJsonFilePreservingStyle((0, import_node_path5.join)(root, CLAUDE_SETTINGS_FILE), settings);
 }
 async function hasLegacyHooksAt(root) {
   const settings = await readSettingsAt(root);
@@ -11621,7 +11673,7 @@ function registerHooksCommands(program2) {
 var import_node_crypto3 = require("node:crypto");
 
 // src/lib/conversation-buffer.ts
-var import_promises5 = require("node:fs/promises");
+var import_promises6 = require("node:fs/promises");
 var import_node_fs3 = require("node:fs");
 var import_node_child_process5 = require("node:child_process");
 var import_node_crypto = require("node:crypto");
@@ -11633,7 +11685,7 @@ function bufferTmpPath() {
 }
 async function appendToConversationBuffer(prompt, sessionId) {
   try {
-    await (0, import_promises5.mkdir)(VERITY_DIR, { recursive: true });
+    await (0, import_promises6.mkdir)(VERITY_DIR, { recursive: true });
     let sanitized = prompt.length > MAX_INTENT_CHARS ? prompt.slice(0, MAX_INTENT_CHARS) : prompt;
     sanitized = stripImageReferences(sanitized);
     const entry = {
@@ -11651,8 +11703,8 @@ async function appendToConversationBuffer(prompt, sessionId) {
     const capped = recent.slice(-CONVERSATION_MAX_ENTRIES);
     const content = capped.map((e) => JSON.stringify(e)).join("\n") + "\n";
     const tmpFile = bufferTmpPath();
-    await (0, import_promises5.writeFile)(tmpFile, content);
-    await (0, import_promises5.rename)(tmpFile, CONVERSATION_BUFFER_FILE);
+    await (0, import_promises6.writeFile)(tmpFile, content);
+    await (0, import_promises6.rename)(tmpFile, CONVERSATION_BUFFER_FILE);
   } catch {
   }
 }
@@ -11669,10 +11721,10 @@ async function readAndClearConversationBuffer(currentSessionId) {
       if (others.length > 0) {
         const remaining = others.map((e) => JSON.stringify(e)).join("\n") + "\n";
         const tmpFile = bufferTmpPath();
-        await (0, import_promises5.writeFile)(tmpFile, remaining);
-        await (0, import_promises5.rename)(tmpFile, CONVERSATION_BUFFER_FILE);
+        await (0, import_promises6.writeFile)(tmpFile, remaining);
+        await (0, import_promises6.rename)(tmpFile, CONVERSATION_BUFFER_FILE);
       } else {
-        await (0, import_promises5.unlink)(CONVERSATION_BUFFER_FILE).catch(() => {
+        await (0, import_promises6.unlink)(CONVERSATION_BUFFER_FILE).catch(() => {
         });
       }
       if (mine.length > 0) {
@@ -11684,8 +11736,8 @@ async function readAndClearConversationBuffer(currentSessionId) {
     }
     if ((0, import_node_fs3.existsSync)(INTENT_FILE)) {
       try {
-        const content = await (0, import_promises5.readFile)(INTENT_FILE, "utf-8");
-        await (0, import_promises5.unlink)(INTENT_FILE).catch(() => {
+        const content = await (0, import_promises6.readFile)(INTENT_FILE, "utf-8");
+        await (0, import_promises6.unlink)(INTENT_FILE).catch(() => {
         });
         const data = JSON.parse(content);
         if (data.prompt) {
@@ -11708,7 +11760,7 @@ async function readAndClearConversationBuffer(currentSessionId) {
 }
 async function readBufferEntries() {
   try {
-    const content = await (0, import_promises5.readFile)(CONVERSATION_BUFFER_FILE, "utf-8");
+    const content = await (0, import_promises6.readFile)(CONVERSATION_BUFFER_FILE, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -11738,9 +11790,9 @@ function getRecentCommitMessages() {
 }
 
 // src/lib/task-context-buffer.ts
-var import_promises6 = require("node:fs/promises");
+var import_promises7 = require("node:fs/promises");
 var import_node_fs4 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_path6 = require("node:path");
 var TASK_CONTEXT_DIR = `${VERITY_DIR}/.task-context`;
 var MAX_BUFFER_BYTES = 500 * 1024;
 var MAX_PROMPT_CHARS = 2e3;
@@ -11781,7 +11833,7 @@ async function readTaskContextBuffer(taskId) {
   const filePath = bufferPath(taskId);
   if (!(0, import_node_fs4.existsSync)(filePath)) return null;
   try {
-    const content = await (0, import_promises6.readFile)(filePath, "utf-8");
+    const content = await (0, import_promises7.readFile)(filePath, "utf-8");
     if (!content.trim()) return null;
     const lines = content.split("\n").filter((l) => l.trim());
     const formatted = [];
@@ -11814,15 +11866,15 @@ async function readTaskContextBuffer(taskId) {
 async function cleanupTaskContextBuffers() {
   try {
     if (!(0, import_node_fs4.existsSync)(TASK_CONTEXT_DIR)) return;
-    const files = await (0, import_promises6.readdir)(TASK_CONTEXT_DIR);
+    const files = await (0, import_promises7.readdir)(TASK_CONTEXT_DIR);
     const cutoffMs = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1e3;
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filePath = (0, import_node_path5.join)(TASK_CONTEXT_DIR, file);
+      const filePath = (0, import_node_path6.join)(TASK_CONTEXT_DIR, file);
       try {
-        const stats = await (0, import_promises6.stat)(filePath);
+        const stats = await (0, import_promises7.stat)(filePath);
         if (stats.mtimeMs < cutoffMs) {
-          await (0, import_promises6.unlink)(filePath);
+          await (0, import_promises7.unlink)(filePath);
         }
       } catch {
       }
@@ -11832,33 +11884,33 @@ async function cleanupTaskContextBuffers() {
 }
 function bufferPath(taskId) {
   const safe = taskId.replace(/[^a-zA-Z0-9_-]/g, "");
-  return (0, import_node_path5.join)(TASK_CONTEXT_DIR, `${safe}.jsonl`);
+  return (0, import_node_path6.join)(TASK_CONTEXT_DIR, `${safe}.jsonl`);
 }
 async function appendEntry(taskId, entry) {
   try {
-    await (0, import_promises6.mkdir)(TASK_CONTEXT_DIR, { recursive: true });
+    await (0, import_promises7.mkdir)(TASK_CONTEXT_DIR, { recursive: true });
     const filePath = bufferPath(taskId);
     if ((0, import_node_fs4.existsSync)(filePath)) {
-      const stats = await (0, import_promises6.stat)(filePath);
+      const stats = await (0, import_promises7.stat)(filePath);
       if (stats.size >= MAX_BUFFER_BYTES) {
-        const content = await (0, import_promises6.readFile)(filePath, "utf-8");
+        const content = await (0, import_promises7.readFile)(filePath, "utf-8");
         const lines = content.split("\n").filter((l) => l.trim());
         const keepFrom = Math.floor(lines.length * 0.25);
         const pruned = lines.slice(keepFrom).join("\n") + "\n";
-        await (0, import_promises6.writeFile)(filePath, pruned);
+        await (0, import_promises7.writeFile)(filePath, pruned);
       }
     }
     const line = JSON.stringify(entry) + "\n";
-    const existing = (0, import_node_fs4.existsSync)(filePath) ? await (0, import_promises6.readFile)(filePath, "utf-8") : "";
-    await (0, import_promises6.writeFile)(filePath, existing + line);
+    const existing = (0, import_node_fs4.existsSync)(filePath) ? await (0, import_promises7.readFile)(filePath, "utf-8") : "";
+    await (0, import_promises7.writeFile)(filePath, existing + line);
   } catch {
   }
 }
 
 // src/lib/memory-retrieval.ts
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_fs5 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_path7 = require("node:path");
 var memoryDir = () => projectPath(`${VERITY_DIR}/memory`);
 var DOMAINS = ["decisions", "quality", "security", "intent", "gotchas", "patterns", "domain", "integrations"];
 var DEFAULT_BUDGET_TOKENS = 2e3;
@@ -11956,14 +12008,14 @@ async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = D
   const promptTokens = tokenize(promptText);
   const nodes = [];
   for (const domain of DOMAINS) {
-    const domainDir = (0, import_node_path6.join)(memoryDir(), domain);
+    const domainDir = (0, import_node_path7.join)(memoryDir(), domain);
     if (!(0, import_node_fs5.existsSync)(domainDir)) continue;
     try {
-      const files = await (0, import_promises7.readdir)(domainDir);
+      const files = await (0, import_promises8.readdir)(domainDir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
         try {
-          const content = await (0, import_promises7.readFile)((0, import_node_path6.join)(domainDir, file), "utf-8");
+          const content = await (0, import_promises8.readFile)((0, import_node_path7.join)(domainDir, file), "utf-8");
           const { fm, body } = parseFrontmatter(content);
           if (fm.status && fm.status !== "active") continue;
           nodes.push({
@@ -12021,9 +12073,9 @@ async function retrieveForInjection(promptText, taskFiles = [], budgetTokens = D
 }
 
 // src/lib/memory-sync.ts
-var import_promises8 = require("node:fs/promises");
+var import_promises9 = require("node:fs/promises");
 var import_node_fs6 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_path8 = require("node:path");
 var import_node_crypto2 = require("node:crypto");
 
 // src/lib/glob-match.ts
@@ -12092,18 +12144,18 @@ var memoryDir2 = () => projectPath(`${VERITY_DIR}/memory`);
 var DOMAINS2 = ["decisions", "quality", "security", "intent", "gotchas", "patterns", "domain", "integrations", "_archive"];
 var syncStateFile = () => projectPath(`${VERITY_DIR}/.memory-sync-state.json`);
 async function ensureMemoryDir() {
-  await (0, import_promises8.mkdir)(memoryDir2(), { recursive: true });
+  await (0, import_promises9.mkdir)(memoryDir2(), { recursive: true });
   for (const domain of DOMAINS2) {
-    await (0, import_promises8.mkdir)((0, import_node_path7.join)(memoryDir2(), domain), { recursive: true });
+    await (0, import_promises9.mkdir)((0, import_node_path8.join)(memoryDir2(), domain), { recursive: true });
   }
-  if (!(0, import_node_fs6.existsSync)((0, import_node_path7.join)(memoryDir2(), "SCHEMA.md"))) {
-    await (0, import_promises8.writeFile)((0, import_node_path7.join)(memoryDir2(), "SCHEMA.md"), SCHEMA_TEMPLATE);
+  if (!(0, import_node_fs6.existsSync)((0, import_node_path8.join)(memoryDir2(), "SCHEMA.md"))) {
+    await (0, import_promises9.writeFile)((0, import_node_path8.join)(memoryDir2(), "SCHEMA.md"), SCHEMA_TEMPLATE);
   }
-  if (!(0, import_node_fs6.existsSync)((0, import_node_path7.join)(memoryDir2(), "index.md"))) {
-    await (0, import_promises8.writeFile)((0, import_node_path7.join)(memoryDir2(), "index.md"), "# Project Memory Index\n\nNo nodes yet. Run an analysis to start building the knowledge graph.\n");
+  if (!(0, import_node_fs6.existsSync)((0, import_node_path8.join)(memoryDir2(), "index.md"))) {
+    await (0, import_promises9.writeFile)((0, import_node_path8.join)(memoryDir2(), "index.md"), "# Project Memory Index\n\nNo nodes yet. Run an analysis to start building the knowledge graph.\n");
   }
-  if (!(0, import_node_fs6.existsSync)((0, import_node_path7.join)(memoryDir2(), "log.md"))) {
-    await (0, import_promises8.writeFile)((0, import_node_path7.join)(memoryDir2(), "log.md"), "# Memory Log\n\n");
+  if (!(0, import_node_fs6.existsSync)((0, import_node_path8.join)(memoryDir2(), "log.md"))) {
+    await (0, import_promises9.writeFile)((0, import_node_path8.join)(memoryDir2(), "log.md"), "# Memory Log\n\n");
   }
 }
 async function buildManifest() {
@@ -12112,16 +12164,16 @@ async function buildManifest() {
   }
   const nodes = [];
   for (const domain of DOMAINS2) {
-    const domainDir = (0, import_node_path7.join)(memoryDir2(), domain);
+    const domainDir = (0, import_node_path8.join)(memoryDir2(), domain);
     if (!(0, import_node_fs6.existsSync)(domainDir)) continue;
     try {
-      const files = await (0, import_promises8.readdir)(domainDir);
+      const files = await (0, import_promises9.readdir)(domainDir);
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
         const filePath = `${domain}/${file}`;
-        const fullPath = (0, import_node_path7.join)(memoryDir2(), filePath);
+        const fullPath = (0, import_node_path8.join)(memoryDir2(), filePath);
         try {
-          const content = await (0, import_promises8.readFile)(fullPath, "utf-8");
+          const content = await (0, import_promises9.readFile)(fullPath, "utf-8");
           const hash = (0, import_node_crypto2.createHash)("sha256").update(content).digest("hex").slice(0, 16);
           nodes.push({ path: filePath, content_hash: `sha256:${hash}` });
         } catch {
@@ -12132,13 +12184,13 @@ async function buildManifest() {
   }
   let indexHash = null;
   try {
-    const indexContent = await (0, import_promises8.readFile)((0, import_node_path7.join)(memoryDir2(), "index.md"), "utf-8");
+    const indexContent = await (0, import_promises9.readFile)((0, import_node_path8.join)(memoryDir2(), "index.md"), "utf-8");
     indexHash = `sha256:${(0, import_node_crypto2.createHash)("sha256").update(indexContent).digest("hex").slice(0, 16)}`;
   } catch {
   }
   let logLength = 0;
   try {
-    const logContent = await (0, import_promises8.readFile)((0, import_node_path7.join)(memoryDir2(), "log.md"), "utf-8");
+    const logContent = await (0, import_promises9.readFile)((0, import_node_path8.join)(memoryDir2(), "log.md"), "utf-8");
     logLength = logContent.split("\n").length;
   } catch {
   }
@@ -12151,13 +12203,13 @@ async function readOnDiskNodes() {
   const out = /* @__PURE__ */ new Map();
   if (!(0, import_node_fs6.existsSync)(memoryDir2())) return out;
   for (const domain of DOMAINS2) {
-    const domainDir = (0, import_node_path7.join)(memoryDir2(), domain);
+    const domainDir = (0, import_node_path8.join)(memoryDir2(), domain);
     if (!(0, import_node_fs6.existsSync)(domainDir)) continue;
     try {
-      for (const file of await (0, import_promises8.readdir)(domainDir)) {
+      for (const file of await (0, import_promises9.readdir)(domainDir)) {
         if (!file.endsWith(".md")) continue;
         try {
-          out.set(`${domain}/${file}`, hashContent(await (0, import_promises8.readFile)((0, import_node_path7.join)(domainDir, file), "utf-8")));
+          out.set(`${domain}/${file}`, hashContent(await (0, import_promises9.readFile)((0, import_node_path8.join)(domainDir, file), "utf-8")));
         } catch {
         }
       }
@@ -12169,7 +12221,7 @@ async function readOnDiskNodes() {
 async function readSyncBaseline() {
   const out = /* @__PURE__ */ new Map();
   try {
-    const parsed = JSON.parse(await (0, import_promises8.readFile)(syncStateFile(), "utf-8"));
+    const parsed = JSON.parse(await (0, import_promises9.readFile)(syncStateFile(), "utf-8"));
     if (Array.isArray(parsed?.nodes)) {
       for (const n of parsed.nodes) if (n?.path) out.set(n.path, n.hash ?? null);
     } else if (Array.isArray(parsed?.paths)) {
@@ -12185,12 +12237,12 @@ async function recordSyncedNodePaths() {
     const next = JSON.stringify({ schema: 2, nodes }) + "\n";
     let existing = "";
     try {
-      existing = await (0, import_promises8.readFile)(syncStateFile(), "utf-8");
+      existing = await (0, import_promises9.readFile)(syncStateFile(), "utf-8");
     } catch {
     }
     if (existing === next) return;
-    await (0, import_promises8.mkdir)(projectPath(VERITY_DIR), { recursive: true });
-    await (0, import_promises8.writeFile)(syncStateFile(), next);
+    await (0, import_promises9.mkdir)(projectPath(VERITY_DIR), { recursive: true });
+    await (0, import_promises9.writeFile)(syncStateFile(), next);
   } catch {
   }
 }
@@ -12203,11 +12255,11 @@ async function computeEditedNodeUploads() {
   const uploads = [];
   for (const [path, prevHash] of prev) {
     if (prevHash == null) continue;
-    const full = (0, import_node_path7.join)(memoryDir2(), path);
+    const full = (0, import_node_path8.join)(memoryDir2(), path);
     if (!(0, import_node_fs6.existsSync)(full)) continue;
     let content;
     try {
-      content = await (0, import_promises8.readFile)(full, "utf-8");
+      content = await (0, import_promises9.readFile)(full, "utf-8");
     } catch {
       continue;
     }
@@ -12240,15 +12292,15 @@ async function applyMemoryWrites(writes, opts = {}) {
   const logLines = [`- ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16)} \u2014 Applied ${count} write(s) from server`];
   for (const n of notes) logLines.push(`  - ${n}`);
   try {
-    const existing = (0, import_node_fs6.existsSync)((0, import_node_path7.join)(memoryDir2(), "log.md")) ? await (0, import_promises8.readFile)((0, import_node_path7.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
-    await (0, import_promises8.writeFile)((0, import_node_path7.join)(memoryDir2(), "log.md"), existing + logLines.join("\n") + "\n");
+    const existing = (0, import_node_fs6.existsSync)((0, import_node_path8.join)(memoryDir2(), "log.md")) ? await (0, import_promises9.readFile)((0, import_node_path8.join)(memoryDir2(), "log.md"), "utf-8") : "# Memory Log\n\n";
+    await (0, import_promises9.writeFile)((0, import_node_path8.join)(memoryDir2(), "log.md"), existing + logLines.join("\n") + "\n");
   } catch {
   }
   await recordSyncedNodePaths();
   return count;
 }
 async function applyOneWrite(write, treePaths) {
-  const fullPath = (0, import_node_path7.join)(memoryDir2(), write.path);
+  const fullPath = (0, import_node_path8.join)(memoryDir2(), write.path);
   const notes = [];
   let content = write.content;
   if (treePaths && treePaths.length > 0) {
@@ -12261,7 +12313,7 @@ async function applyOneWrite(write, treePaths) {
   if ((0, import_node_fs6.existsSync)(fullPath)) {
     let existing = "";
     try {
-      existing = await (0, import_promises8.readFile)(fullPath, "utf-8");
+      existing = await (0, import_promises9.readFile)(fullPath, "utf-8");
     } catch {
     }
     if (existing === content) return { written: false, notes };
@@ -12270,8 +12322,8 @@ async function applyOneWrite(write, treePaths) {
       return { written: false, notes };
     }
   }
-  await (0, import_promises8.mkdir)((0, import_node_path7.dirname)(fullPath), { recursive: true });
-  await (0, import_promises8.writeFile)(fullPath, content);
+  await (0, import_promises9.mkdir)((0, import_node_path8.dirname)(fullPath), { recursive: true });
+  await (0, import_promises9.writeFile)(fullPath, content);
   return { written: true, notes };
 }
 function groundFileGlobs(content, treePaths) {
@@ -12311,10 +12363,10 @@ async function regenerateIndex() {
   ];
   let totalNodes = 0;
   for (const domain of DOMAINS2.filter((d) => d !== "_archive")) {
-    const domainDir = (0, import_node_path7.join)(memoryDir2(), domain);
+    const domainDir = (0, import_node_path8.join)(memoryDir2(), domain);
     if (!(0, import_node_fs6.existsSync)(domainDir)) continue;
     try {
-      const files = await (0, import_promises8.readdir)(domainDir);
+      const files = await (0, import_promises9.readdir)(domainDir);
       const mdFiles = files.filter((f) => f.endsWith(".md"));
       if (mdFiles.length === 0) continue;
       lines.push(`## ${domain}/ (${mdFiles.length})`);
@@ -12322,7 +12374,7 @@ async function regenerateIndex() {
       for (const file of mdFiles.sort()) {
         const slug = file.replace(/\.md$/, "");
         try {
-          const content = await (0, import_promises8.readFile)((0, import_node_path7.join)(domainDir, file), "utf-8");
+          const content = await (0, import_promises9.readFile)((0, import_node_path8.join)(domainDir, file), "utf-8");
           const title = pickFrontmatter(content, "title") ?? slug;
           const kind = pickFrontmatter(content, "kind") ?? "-";
           const confidence = pickFrontmatter(content, "confidence");
@@ -12346,14 +12398,14 @@ async function regenerateIndex() {
     lines.push("No nodes yet. Run an analysis to start building the knowledge graph.");
   }
   const next = lines.join("\n") + "\n";
-  const indexPath = (0, import_node_path7.join)(memoryDir2(), "index.md");
+  const indexPath = (0, import_node_path8.join)(memoryDir2(), "index.md");
   let existing = null;
   try {
-    existing = await (0, import_promises8.readFile)(indexPath, "utf-8");
+    existing = await (0, import_promises9.readFile)(indexPath, "utf-8");
   } catch {
   }
   if (existing === next) return;
-  await (0, import_promises8.writeFile)(indexPath, next);
+  await (0, import_promises9.writeFile)(indexPath, next);
 }
 function pickFrontmatter(content, key) {
   const re = new RegExp(`^${key}:\\s*"?([^"\\n]+?)"?\\s*$`, "m");
@@ -12428,10 +12480,10 @@ function hasLegacyMemoryBlock(text) {
   return findMarker(text, LEGACY_MD_START) !== -1;
 }
 async function ensureClaudeMdPointer(cwd = repoRoot()) {
-  const claudeMdPath = (0, import_node_path7.join)(cwd, "CLAUDE.md");
+  const claudeMdPath = (0, import_node_path8.join)(cwd, "CLAUDE.md");
   let existing = "";
   if ((0, import_node_fs6.existsSync)(claudeMdPath)) {
-    existing = await (0, import_promises8.readFile)(claudeMdPath, "utf-8");
+    existing = await (0, import_promises9.readFile)(claudeMdPath, "utf-8");
   }
   let startTag = CLAUDE_MD_START;
   let endTag = CLAUDE_MD_END;
@@ -12487,7 +12539,7 @@ async function ensureClaudeMdPointer(cwd = repoRoot()) {
     next = existing.replace(/\n*$/, "") + "\n\n" + block + "\n";
   }
   if (next === existing) return;
-  await (0, import_promises8.writeFile)(claudeMdPath, next);
+  await (0, import_promises9.writeFile)(claudeMdPath, next);
 }
 function extractPreserveContent(interior) {
   for (const [start, end] of [
@@ -12670,7 +12722,7 @@ async function fireClassify(prompt, sessionId) {
 }
 
 // src/commands/standard.ts
-var import_promises9 = require("node:fs/promises");
+var import_promises10 = require("node:fs/promises");
 var import_yaml = __toESM(require_dist());
 function registerStandardCommands(program2) {
   const standard = program2.command("standard").description("Manage the project Standard");
@@ -12688,7 +12740,7 @@ function registerStandardCommands(program2) {
     }
     let yamlContent;
     try {
-      yamlContent = await (0, import_promises9.readFile)(opts.file, "utf-8");
+      yamlContent = await (0, import_promises10.readFile)(opts.file, "utf-8");
     } catch {
       printError(`Cannot read ${opts.file}`);
       process.exit(1);
@@ -12779,7 +12831,7 @@ function registerStandardCommands(program2) {
 }
 
 // src/commands/config.ts
-var import_promises10 = require("node:fs/promises");
+var import_promises11 = require("node:fs/promises");
 function registerConfigCommands(program2) {
   const config = program2.command("config").description("Manage analysis configuration");
   config.command("push").description("Upload the analysis config to the service").option("--file <path>", "Path to config file", CODACY_CONFIG_FILE).action(async (opts) => {
@@ -12796,7 +12848,7 @@ function registerConfigCommands(program2) {
     }
     let content;
     try {
-      const raw = await (0, import_promises10.readFile)(opts.file, "utf-8");
+      const raw = await (0, import_promises11.readFile)(opts.file, "utf-8");
       content = JSON.parse(raw);
     } catch {
       printError(`Cannot read or parse ${opts.file}`);
@@ -13146,11 +13198,11 @@ async function sendGeneralFeedback(message, opts, globals) {
 
 // src/commands/analyze.ts
 var import_node_fs19 = require("node:fs");
-var import_node_path14 = require("node:path");
+var import_node_path15 = require("node:path");
 
 // src/lib/files.ts
 var import_node_fs8 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_path9 = require("node:path");
 var LANG_MAP = {
   // Analyzable (static analysis + Gemini)
   ts: "typescript",
@@ -13218,7 +13270,7 @@ var LANG_MAP = {
   mk: "make"
 };
 function detectLanguage(filepath) {
-  const ext = (0, import_node_path8.extname)(filepath).slice(1);
+  const ext = (0, import_node_path9.extname)(filepath).slice(1);
   return LANG_MAP[ext] ?? ext;
 }
 function sortByMtime(files) {
@@ -13504,7 +13556,7 @@ function runCodacyAnalysis(files) {
 
 // src/lib/specs.ts
 var import_node_fs11 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_path10 = require("node:path");
 var SPEC_CANDIDATES = [
   "CLAUDE.md",
   "AGENTS.md",
@@ -13566,7 +13618,7 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   try {
     const entries = (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = (0, import_node_path9.join)(dir, entry.name);
+      const fullPath = (0, import_node_path10.join)(dir, entry.name);
       if (entry.isFile() && entry.name.endsWith(".md")) {
         result.push(fullPath);
       } else if (entry.isDirectory() && depth < maxDepth - 1) {
@@ -13578,7 +13630,7 @@ function findMdFiles(dir, maxDepth, depth = 0) {
   return result;
 }
 function discoverPlans() {
-  const homePlansDir = (0, import_node_path9.join)(process.env.HOME ?? "", ".claude", "plans");
+  const homePlansDir = (0, import_node_path10.join)(process.env.HOME ?? "", ".claude", "plans");
   const localPlansDir = ".claude/plans";
   const candidates = [];
   const seen = /* @__PURE__ */ new Set();
@@ -13588,7 +13640,7 @@ function discoverPlans() {
       for (const f of (0, import_node_fs11.readdirSync)(plansDir)) {
         if (!f.endsWith(".md") || seen.has(f)) continue;
         seen.add(f);
-        const fullPath = (0, import_node_path9.join)(plansDir, f);
+        const fullPath = (0, import_node_path10.join)(plansDir, f);
         try {
           const stat3 = (0, import_node_fs11.statSync)(fullPath);
           candidates.push({ name: f, path: fullPath, mtime: stat3.mtimeMs, size: stat3.size });
@@ -13613,7 +13665,7 @@ function discoverPlans() {
 
 // src/lib/snapshot.ts
 var import_node_fs12 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_path11 = require("node:path");
 var import_node_child_process7 = require("node:child_process");
 function generateSnapshotDiffs(files) {
   if (!(0, import_node_fs12.existsSync)(SNAPSHOT_DIR)) {
@@ -13621,7 +13673,7 @@ function generateSnapshotDiffs(files) {
   }
   const diffs = [];
   for (const file of files) {
-    const snapshotPath = (0, import_node_path10.join)(SNAPSHOT_DIR, file.path);
+    const snapshotPath = (0, import_node_path11.join)(SNAPSHOT_DIR, file.path);
     const language = file.language ?? detectLanguage(file.path);
     if ((0, import_node_fs12.existsSync)(snapshotPath)) {
       const oldContent = (0, import_node_fs12.readFileSync)(snapshotPath, "utf-8");
@@ -13648,16 +13700,16 @@ ${addedLines}`,
 function saveSnapshots(files) {
   const snapshotPaths = /* @__PURE__ */ new Set();
   for (const file of files) {
-    const snapshotPath = (0, import_node_path10.join)(SNAPSHOT_DIR, file.path);
+    const snapshotPath = (0, import_node_path11.join)(SNAPSHOT_DIR, file.path);
     snapshotPaths.add(snapshotPath);
-    (0, import_node_fs12.mkdirSync)((0, import_node_path10.dirname)(snapshotPath), { recursive: true });
+    (0, import_node_fs12.mkdirSync)((0, import_node_path11.dirname)(snapshotPath), { recursive: true });
     (0, import_node_fs12.writeFileSync)(snapshotPath, file.content);
   }
   cleanStaleSnapshots(SNAPSHOT_DIR, snapshotPaths);
 }
 function computeDiff(oldContent, newContent, filePath) {
-  const tmpOld = (0, import_node_path10.join)(SNAPSHOT_DIR, ".diff-old.tmp");
-  const tmpNew = (0, import_node_path10.join)(SNAPSHOT_DIR, ".diff-new.tmp");
+  const tmpOld = (0, import_node_path11.join)(SNAPSHOT_DIR, ".diff-old.tmp");
+  const tmpNew = (0, import_node_path11.join)(SNAPSHOT_DIR, ".diff-new.tmp");
   try {
     (0, import_node_fs12.mkdirSync)(SNAPSHOT_DIR, { recursive: true });
     (0, import_node_fs12.writeFileSync)(tmpOld, oldContent);
@@ -13690,7 +13742,7 @@ function cleanStaleSnapshots(dir, keepSet) {
     const entries = (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const fullPath = (0, import_node_path10.join)(dir, entry.name);
+      const fullPath = (0, import_node_path11.join)(dir, entry.name);
       if (entry.isDirectory()) {
         cleanStaleSnapshots(fullPath, keepSet);
         try {
@@ -13711,7 +13763,7 @@ function cleanStaleSnapshots(dir, keepSet) {
 
 // src/lib/baseline.ts
 var import_node_fs13 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_path12 = require("node:path");
 var import_node_crypto5 = require("node:crypto");
 var BASELINE_VERSION = 1;
 var BASELINE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
@@ -13722,13 +13774,13 @@ function sessionKey(sessionId) {
   return (0, import_node_crypto5.createHash)("sha256").update(sessionId).digest("hex").slice(0, 16);
 }
 function sessionDir(key) {
-  return (0, import_node_path11.join)(projectPath(BASELINE_DIR), key);
+  return (0, import_node_path12.join)(projectPath(BASELINE_DIR), key);
 }
 function manifestPath(dir) {
-  return (0, import_node_path11.join)(dir, "manifest.json");
+  return (0, import_node_path12.join)(dir, "manifest.json");
 }
 function mirrorPath(dir, repoRelPath) {
-  return (0, import_node_path11.join)(dir, "files", repoRelPath);
+  return (0, import_node_path12.join)(dir, "files", repoRelPath);
 }
 function captureBaseline(opts = {}) {
   const key = sessionKey(opts.sessionId);
@@ -13744,7 +13796,7 @@ function captureBaseline(opts = {}) {
     (0, import_node_fs13.rmSync)(dir, { recursive: true, force: true });
   } catch {
   }
-  const filesDir = (0, import_node_path11.join)(dir, "files");
+  const filesDir = (0, import_node_path12.join)(dir, "files");
   const mirrored = [];
   try {
     (0, import_node_fs13.mkdirSync)(filesDir, { recursive: true });
@@ -13754,7 +13806,7 @@ function captureBaseline(opts = {}) {
       if (content === null) continue;
       const dest = mirrorPath(dir, p);
       try {
-        (0, import_node_fs13.mkdirSync)((0, import_node_path11.dirname)(dest), { recursive: true });
+        (0, import_node_fs13.mkdirSync)((0, import_node_path12.dirname)(dest), { recursive: true });
         (0, import_node_fs13.writeFileSync)(dest, content);
         mirrored.push(p);
       } catch {
@@ -13882,7 +13934,7 @@ function pruneOldBaselines() {
   }
   const now = Date.now();
   for (const name of entries) {
-    const dir = (0, import_node_path11.join)(root, name);
+    const dir = (0, import_node_path12.join)(root, name);
     const manifest = readManifest(dir);
     if (!manifest) {
       try {
@@ -13981,7 +14033,7 @@ function gatherContextFiles(contextPaths, deltaFiles) {
 
 // src/lib/cache-cleanup.ts
 var import_node_fs16 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_path13 = require("node:path");
 var CACHE_TTL_DAYS = 7;
 function pruneStaleCache() {
   try {
@@ -13989,7 +14041,7 @@ function pruneStaleCache() {
     const cutoff = Date.now() - CACHE_TTL_DAYS * 24 * 3600 * 1e3;
     for (const entry of (0, import_node_fs16.readdirSync)(dir)) {
       if (!entry.startsWith("pending-")) continue;
-      const path = (0, import_node_path12.join)(dir, entry);
+      const path = (0, import_node_path13.join)(dir, entry);
       try {
         const stat3 = (0, import_node_fs16.statSync)(path);
         if (stat3.mtimeMs < cutoff) {
@@ -14380,9 +14432,9 @@ function capArray(set, max) {
 }
 
 // src/lib/seed-runner.ts
-var import_promises11 = require("node:fs/promises");
+var import_promises12 = require("node:fs/promises");
 var import_node_fs18 = require("node:fs");
-var import_node_path13 = require("node:path");
+var import_node_path14 = require("node:path");
 var import_yaml2 = __toESM(require_dist());
 
 // src/lib/seed.ts
@@ -14626,7 +14678,7 @@ async function runSeed(opts) {
   }
   let standardDoc;
   try {
-    const raw = await (0, import_promises11.readFile)(STANDARD_FILE, "utf-8");
+    const raw = await (0, import_promises12.readFile)(STANDARD_FILE, "utf-8");
     standardDoc = (0, import_yaml2.parse)(raw);
   } catch {
     return { created: 0, failed: 0, skipped: "no_standard", candidates: [] };
@@ -14635,7 +14687,7 @@ async function runSeed(opts) {
   let readmeContent;
   if ((0, import_node_fs18.existsSync)("README.md")) {
     try {
-      readmeContent = await (0, import_promises11.readFile)("README.md", "utf-8");
+      readmeContent = await (0, import_promises12.readFile)("README.md", "utf-8");
     } catch {
     }
   }
@@ -14643,7 +14695,7 @@ async function runSeed(opts) {
   for (const p of ["CLAUDE.md", ".claude/CLAUDE.md"]) {
     if ((0, import_node_fs18.existsSync)(p)) {
       try {
-        claudeMdContent = await (0, import_promises11.readFile)(p, "utf-8");
+        claudeMdContent = await (0, import_promises12.readFile)(p, "utf-8");
         break;
       } catch {
       }
@@ -14664,7 +14716,7 @@ async function runSeed(opts) {
   if (candidates.length === 0) {
     return { created: 0, failed: 0, skipped: "no_candidates", candidates: [] };
   }
-  const overviewPath = (0, import_node_path13.join)(MEMORY_DIR, "domain", "project-overview.md");
+  const overviewPath = (0, import_node_path14.join)(MEMORY_DIR, "domain", "project-overview.md");
   if ((0, import_node_fs18.existsSync)(overviewPath) && !opts.force) {
     return { created: 0, failed: 0, skipped: "already_seeded", candidates };
   }
@@ -14700,10 +14752,10 @@ async function runSeed(opts) {
     }
     const nodeId = res.data.node_id;
     const filePathRel = res.data.file_path;
-    const targetPath = (0, import_node_path13.join)(MEMORY_DIR, filePathRel);
+    const targetPath = (0, import_node_path14.join)(MEMORY_DIR, filePathRel);
     try {
-      await (0, import_promises11.mkdir)((0, import_node_path13.dirname)(targetPath), { recursive: true });
-      await (0, import_promises11.writeFile)(targetPath, renderNodeMarkdown(c, nodeId, createdAt));
+      await (0, import_promises12.mkdir)((0, import_node_path14.dirname)(targetPath), { recursive: true });
+      await (0, import_promises12.writeFile)(targetPath, renderNodeMarkdown(c, nodeId, createdAt));
       created++;
       opts.onCreated?.(nodeId, filePathRel, c);
     } catch (err) {
@@ -14984,7 +15036,7 @@ async function runAnalyze(opts, globals) {
   let autoSeedNotice = null;
   try {
     await ensureMemoryDir();
-    const seedMarker = (0, import_node_path14.join)(VERITY_DIR, ".seeded");
+    const seedMarker = (0, import_node_path15.join)(VERITY_DIR, ".seeded");
     const hasStandard = (0, import_node_fs19.existsSync)(STANDARD_FILE);
     const alreadyTried = (0, import_node_fs19.existsSync)(seedMarker);
     if (hasStandard && !alreadyTried) {
@@ -15478,9 +15530,9 @@ async function runReview(opts, globals) {
 
 // src/commands/guard.ts
 var import_node_fs22 = require("node:fs");
-var import_node_path15 = require("node:path");
+var import_node_path16 = require("node:path");
 var GUARD_BLOCK_CAP = 2;
-var GUARD_ITER_FILE = (0, import_node_path15.join)(VERITY_DIR, ".guard-iteration");
+var GUARD_ITER_FILE = (0, import_node_path16.join)(VERITY_DIR, ".guard-iteration");
 function readPreToolUseStdin() {
   const empty = { command: "", cwd: null, sessionId: null };
   return new Promise((resolve) => {
@@ -15795,14 +15847,14 @@ function writeBlockMessage(moment, response) {
 
 // src/commands/init.ts
 var import_node_fs24 = require("node:fs");
-var import_promises12 = require("node:fs/promises");
-var import_node_path17 = require("node:path");
+var import_promises13 = require("node:fs/promises");
+var import_node_path18 = require("node:path");
 var import_node_child_process9 = require("node:child_process");
 var readline = __toESM(require("node:readline/promises"));
 
 // src/commands/migrate.ts
 var import_node_fs23 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_path17 = require("node:path");
 var import_node_child_process8 = require("node:child_process");
 var LEGACY_NPM_PACKAGE = "@codacy/gate-cli";
 function defaultNpmRemover(pkg) {
@@ -15838,8 +15890,8 @@ async function runMigration(opts = {}) {
   return { actions, migrated: actions.length > 0 };
 }
 function migrateProjectDir(root, actions) {
-  const gateDir = (0, import_node_path16.join)(root, ".gate");
-  const verityDir = (0, import_node_path16.join)(root, ".verity");
+  const gateDir = (0, import_node_path17.join)(root, ".gate");
+  const verityDir = (0, import_node_path17.join)(root, ".verity");
   if ((0, import_node_fs23.existsSync)(gateDir) && !(0, import_node_fs23.existsSync)(verityDir)) {
     return migrateProjectDirRename(root, gateDir, verityDir, actions);
   }
@@ -15893,11 +15945,11 @@ function migrateProjectDirCarry(gateDir, verityDir, actions) {
 }
 function migrateGlobalCredentials(home, actions) {
   if (!home) return;
-  const gateCreds = (0, import_node_path16.join)(home, ".gate", "credentials");
-  const verityCreds = (0, import_node_path16.join)(home, ".verity", "credentials");
+  const gateCreds = (0, import_node_path17.join)(home, ".gate", "credentials");
+  const verityCreds = (0, import_node_path17.join)(home, ".verity", "credentials");
   if (!(0, import_node_fs23.existsSync)(gateCreds)) return;
   if (!(0, import_node_fs23.existsSync)(verityCreds)) {
-    (0, import_node_fs23.mkdirSync)((0, import_node_path16.join)(home, ".verity"), { recursive: true });
+    (0, import_node_fs23.mkdirSync)((0, import_node_path17.join)(home, ".verity"), { recursive: true });
     moveFile(gateCreds, verityCreds);
     actions.push("Moved ~/.gate/credentials \u2192 ~/.verity/credentials");
     return;
@@ -15919,7 +15971,7 @@ async function migrateLegacyHooks(root, actions) {
   }
 }
 async function migrateClaudeMd(root, actions) {
-  const claudeMd = (0, import_node_path16.join)(root, "CLAUDE.md");
+  const claudeMd = (0, import_node_path17.join)(root, "CLAUDE.md");
   const hadLegacyBlock = (0, import_node_fs23.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd));
   if (!hadLegacyBlock) return;
   try {
@@ -15930,8 +15982,8 @@ async function migrateClaudeMd(root, actions) {
   }
 }
 function migrateStandardFile(root, actions) {
-  const gateMd = (0, import_node_path16.join)(root, "GATE.md");
-  const verityMd = (0, import_node_path16.join)(root, "VERITY.md");
+  const gateMd = (0, import_node_path17.join)(root, "GATE.md");
+  const verityMd = (0, import_node_path17.join)(root, "VERITY.md");
   if (!(0, import_node_fs23.existsSync)(gateMd) || (0, import_node_fs23.existsSync)(verityMd)) return;
   let moved = false;
   if (isGitRepo(root) && isGitTracked(root, "GATE.md")) {
@@ -16019,15 +16071,15 @@ function moveFile(from, to) {
 function carryLegacyContents(gateDir, verityDir) {
   let copied = 0;
   const walk = (relDir) => {
-    const srcDir = (0, import_node_path16.join)(gateDir, relDir);
+    const srcDir = (0, import_node_path17.join)(gateDir, relDir);
     for (const entry of (0, import_node_fs23.readdirSync)(srcDir)) {
-      const rel = relDir ? (0, import_node_path16.join)(relDir, entry) : entry;
-      const src = (0, import_node_path16.join)(gateDir, rel);
-      const dest = (0, import_node_path16.join)(verityDir, rel);
+      const rel = relDir ? (0, import_node_path17.join)(relDir, entry) : entry;
+      const src = (0, import_node_path17.join)(gateDir, rel);
+      const dest = (0, import_node_path17.join)(verityDir, rel);
       if ((0, import_node_fs23.statSync)(src).isDirectory()) {
         walk(rel);
       } else if (!(0, import_node_fs23.existsSync)(dest)) {
-        (0, import_node_fs23.mkdirSync)((0, import_node_path16.dirname)(dest), { recursive: true });
+        (0, import_node_fs23.mkdirSync)((0, import_node_path17.dirname)(dest), { recursive: true });
         (0, import_node_fs23.cpSync)(src, dest);
         copied++;
       }
@@ -16037,22 +16089,22 @@ function carryLegacyContents(gateDir, verityDir) {
   return copied;
 }
 async function needsMigration(root = repoRoot()) {
-  const gateDir = (0, import_node_path16.join)(root, ".gate");
-  const verityDir = (0, import_node_path16.join)(root, ".verity");
+  const gateDir = (0, import_node_path17.join)(root, ".gate");
+  const verityDir = (0, import_node_path17.join)(root, ".verity");
   if ((0, import_node_fs23.existsSync)(gateDir) && !(0, import_node_fs23.existsSync)(verityDir)) return true;
   if ((0, import_node_fs23.existsSync)(gateDir) && (0, import_node_fs23.existsSync)(verityDir)) {
-    if ((0, import_node_fs23.existsSync)((0, import_node_path16.join)(gateDir, "credentials")) && !(0, import_node_fs23.existsSync)((0, import_node_path16.join)(verityDir, "credentials"))) {
+    if ((0, import_node_fs23.existsSync)((0, import_node_path17.join)(gateDir, "credentials")) && !(0, import_node_fs23.existsSync)((0, import_node_path17.join)(verityDir, "credentials"))) {
       return true;
     }
-    if ((0, import_node_fs23.existsSync)((0, import_node_path16.join)(gateDir, "memory")) && !(0, import_node_fs23.existsSync)((0, import_node_path16.join)(verityDir, "memory"))) {
+    if ((0, import_node_fs23.existsSync)((0, import_node_path17.join)(gateDir, "memory")) && !(0, import_node_fs23.existsSync)((0, import_node_path17.join)(verityDir, "memory"))) {
       return true;
     }
   }
-  const claudeMd = (0, import_node_path16.join)(root, "CLAUDE.md");
+  const claudeMd = (0, import_node_path17.join)(root, "CLAUDE.md");
   if ((0, import_node_fs23.existsSync)(claudeMd) && hasLegacyMemoryBlock(readFileSyncSafe(claudeMd))) {
     return true;
   }
-  if ((0, import_node_fs23.existsSync)((0, import_node_path16.join)(root, "GATE.md")) && !(0, import_node_fs23.existsSync)((0, import_node_path16.join)(root, "VERITY.md"))) {
+  if ((0, import_node_fs23.existsSync)((0, import_node_path17.join)(root, "GATE.md")) && !(0, import_node_fs23.existsSync)((0, import_node_path17.join)(root, "VERITY.md"))) {
     return true;
   }
   if (await hasLegacyHooksAt(root)) return true;
@@ -16127,7 +16179,7 @@ async function runOptionalAuth() {
     localOnlyNote();
     return;
   }
-  const projectName = parseRemote(remote)?.repo ?? (0, import_node_path17.basename)(process.cwd());
+  const projectName = parseRemote(remote)?.repo ?? (0, import_node_path18.basename)(process.cwd());
   printInfo("Authenticating with GitHub\u2026");
   const result = await registerProject({ projectName, remote, serviceUrl: DEFAULT_SERVICE_URL });
   if (result.ok) {
@@ -16140,15 +16192,15 @@ async function runOptionalAuth() {
 }
 function resolveDataDir() {
   const candidates = [
-    (0, import_node_path17.join)(__dirname, "..", "data"),
+    (0, import_node_path18.join)(__dirname, "..", "data"),
     // installed: node_modules/@codacy/verity-cli/data
-    (0, import_node_path17.join)(__dirname, "..", "..", "data"),
+    (0, import_node_path18.join)(__dirname, "..", "..", "data"),
     // edge case: nested resolution
-    (0, import_node_path17.join)(process.cwd(), "cli", "data")
+    (0, import_node_path18.join)(process.cwd(), "cli", "data")
     // local dev: running from repo root
   ];
   for (const candidate of candidates) {
-    if ((0, import_node_fs24.existsSync)((0, import_node_path17.join)(candidate, "skills"))) {
+    if ((0, import_node_fs24.existsSync)((0, import_node_path18.join)(candidate, "skills"))) {
       return candidate;
     }
   }
@@ -16157,8 +16209,8 @@ function resolveDataDir() {
   );
 }
 async function copyDir(src, dest) {
-  await (0, import_promises12.mkdir)(dest, { recursive: true });
-  await (0, import_promises12.cp)(src, dest, { recursive: true, force: true });
+  await (0, import_promises13.mkdir)(dest, { recursive: true });
+  await (0, import_promises13.cp)(src, dest, { recursive: true, force: true });
 }
 function registerInitCommand(program2) {
   program2.command("init").description("Initialize Verity in the current project").option("--force", "Overwrite existing skills and hooks").action(async (opts) => {
@@ -16227,24 +16279,24 @@ function registerInitCommand(program2) {
     console.log("");
     printInfo("Installing skills...");
     const dataDir = resolveDataDir();
-    const skillsSource = (0, import_node_path17.join)(dataDir, "skills");
+    const skillsSource = (0, import_node_path18.join)(dataDir, "skills");
     const skillsDest = ".claude/skills";
     const skills = ["verity-setup", "verity-analyze", "verity-status", "verity-feedback", "verity-learn", "verity-memory", "verity-insights", "verity-reflect"];
     let skillsInstalled = 0;
     for (const skill of skills) {
-      const src = (0, import_node_path17.join)(skillsSource, skill);
-      const dest = (0, import_node_path17.join)(skillsDest, skill);
+      const src = (0, import_node_path18.join)(skillsSource, skill);
+      const dest = (0, import_node_path18.join)(skillsDest, skill);
       if (!(0, import_node_fs24.existsSync)(src)) {
         printWarn(`  Skill data not found: ${skill}`);
         continue;
       }
       if ((0, import_node_fs24.existsSync)(dest) && !force) {
-        const srcSkill = (0, import_node_path17.join)(src, "SKILL.md");
-        const destSkill = (0, import_node_path17.join)(dest, "SKILL.md");
+        const srcSkill = (0, import_node_path18.join)(src, "SKILL.md");
+        const destSkill = (0, import_node_path18.join)(dest, "SKILL.md");
         if ((0, import_node_fs24.existsSync)(destSkill)) {
           try {
-            const srcContent = await (0, import_promises12.readFile)(srcSkill, "utf-8");
-            const destContent = await (0, import_promises12.readFile)(destSkill, "utf-8");
+            const srcContent = await (0, import_promises13.readFile)(srcSkill, "utf-8");
+            const destContent = await (0, import_promises13.readFile)(destSkill, "utf-8");
             if (srcContent === destContent) {
               skillsInstalled++;
               continue;
@@ -16270,7 +16322,7 @@ function registerInitCommand(program2) {
       printWarn(`  ${hookResult.error}`);
       printInfo('  Run "verity hooks install --force" to overwrite.');
     }
-    await (0, import_promises12.mkdir)(VERITY_DIR, { recursive: true });
+    await (0, import_promises13.mkdir)(VERITY_DIR, { recursive: true });
     await ensureMemoryDir();
     try {
       await ensureClaudeMdPointer();
@@ -16278,8 +16330,8 @@ function registerInitCommand(program2) {
     } catch (err) {
       printWarn(`  Could not update CLAUDE.md: ${err.message}`);
     }
-    const globalVerityDir = (0, import_node_path17.join)(process.env.HOME ?? "", ".verity");
-    await (0, import_promises12.mkdir)(globalVerityDir, { recursive: true });
+    const globalVerityDir = (0, import_node_path18.join)(process.env.HOME ?? "", ".verity");
+    await (0, import_promises13.mkdir)(globalVerityDir, { recursive: true });
     console.log("");
     try {
       await runOptionalAuth();
@@ -16309,7 +16361,7 @@ function registerInitCommand(program2) {
 
 // src/commands/uninstall.ts
 var import_node_fs25 = require("node:fs");
-var import_node_path18 = require("node:path");
+var import_node_path19 = require("node:path");
 var SKILL_NAMES = [
   "verity-setup",
   "verity-analyze",
@@ -16328,7 +16380,7 @@ function registerUninstallCommand(program2) {
     const actions = [];
     const skillsRoot = projectPath(".claude/skills");
     for (const name of SKILL_NAMES) {
-      const dir = (0, import_node_path18.join)(skillsRoot, name);
+      const dir = (0, import_node_path19.join)(skillsRoot, name);
       if ((0, import_node_fs25.existsSync)(dir)) {
         actions.push({
           label: `Remove .claude/skills/${name}/`,
@@ -16374,7 +16426,7 @@ function registerUninstallCommand(program2) {
       }
     });
     const home = process.env.HOME ?? "";
-    const globalVerityDir = (0, import_node_path18.join)(home, ".verity");
+    const globalVerityDir = (0, import_node_path19.join)(home, ".verity");
     if (purgeGlobal && (0, import_node_fs25.existsSync)(globalVerityDir)) {
       actions.push({
         label: `Remove ~/.verity/ (global credentials \u2014 reconnect requires re-registration)`,
@@ -16573,7 +16625,7 @@ function registerTaskCommands(program2) {
 
 // src/commands/reset.ts
 var import_node_fs26 = require("node:fs");
-var import_node_path19 = require("node:path");
+var import_node_path20 = require("node:path");
 function registerResetCommand(program2) {
   program2.command("reset").description("Close the current task and clear transient state").option("--keep-task", "Only purge caches; leave the current task open").option("--all", "Also purge diagnostic logs (.verity/.logs/)").action(async (opts) => {
     const globals = program2.opts();
@@ -16614,7 +16666,7 @@ function registerResetCommand(program2) {
       for (const entry of (0, import_node_fs26.readdirSync)(cacheDir)) {
         if (entry.startsWith("pending-")) {
           try {
-            (0, import_node_fs26.unlinkSync)((0, import_node_path19.join)(cacheDir, entry));
+            (0, import_node_fs26.unlinkSync)((0, import_node_path20.join)(cacheDir, entry));
             purged++;
           } catch {
           }
@@ -16641,7 +16693,7 @@ function registerResetCommand(program2) {
       if ((0, import_node_fs26.existsSync)(logsDir)) {
         for (const entry of (0, import_node_fs26.readdirSync)(logsDir)) {
           try {
-            (0, import_node_fs26.unlinkSync)((0, import_node_path19.join)(logsDir, entry));
+            (0, import_node_fs26.unlinkSync)((0, import_node_path20.join)(logsDir, entry));
           } catch {
           }
         }
@@ -16899,8 +16951,7 @@ function registerRunCommand(program2) {
 }
 
 // src/lib/telemetry.ts
-var import_promises13 = require("node:fs/promises");
-var import_node_path20 = require("node:path");
+var import_promises14 = require("node:fs/promises");
 var SETTINGS_LOCAL_FILE2 = ".claude/settings.local.json";
 var GITIGNORE_FILE = ".gitignore";
 var GITIGNORE_ENTRY = ".claude/settings.local.json";
@@ -16931,21 +16982,19 @@ function buildTelemetryEnv(serviceUrl, token) {
 var VERITY_TELEMETRY_KEYS = Object.keys(buildTelemetryEnv("", ""));
 async function readSettingsLocal() {
   try {
-    return JSON.parse(await (0, import_promises13.readFile)(projectPath(SETTINGS_LOCAL_FILE2), "utf-8"));
+    return JSON.parse(await (0, import_promises14.readFile)(projectPath(SETTINGS_LOCAL_FILE2), "utf-8"));
   } catch {
     return {};
   }
 }
 async function writeSettingsLocal(settings) {
-  const file = projectPath(SETTINGS_LOCAL_FILE2);
-  await (0, import_promises13.mkdir)((0, import_node_path20.dirname)(file), { recursive: true });
-  await (0, import_promises13.writeFile)(file, JSON.stringify(settings, null, 2) + "\n");
+  await writeJsonFilePreservingStyle(projectPath(SETTINGS_LOCAL_FILE2), settings);
 }
 async function ensureGitignore() {
   const file = projectPath(GITIGNORE_FILE);
   let content = "";
   try {
-    content = await (0, import_promises13.readFile)(file, "utf-8");
+    content = await (0, import_promises14.readFile)(file, "utf-8");
   } catch {
   }
   const lines = content.split("\n").map((l) => l.trim());
@@ -16954,7 +17003,7 @@ async function ensureGitignore() {
   }
   const block = "# Verity telemetry \u2014 holds your project token\n" + GITIGNORE_ENTRY + "\n";
   const next = content ? content + (content.endsWith("\n") ? "" : "\n") + "\n" + block : block;
-  await (0, import_promises13.writeFile)(file, next);
+  await (0, import_promises14.writeFile)(file, next);
 }
 async function installTelemetry(serviceUrl, token) {
   const env = buildTelemetryEnv(serviceUrl, token);
@@ -17034,7 +17083,7 @@ function registerTelemetryCommands(program2) {
 }
 
 // src/cli.ts
-program.name("verity").description("CLI for Verity quality gate service").version("0.25.0-experimental.ed0c319").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr");
+program.name("verity").description("CLI for Verity quality gate service").version("0.26.0-experimental.d7dfc00").option("--token <token>", "Override authentication token").option("--service-url <url>", "Override service URL").option("--verbose", "Log HTTP requests/responses to stderr");
 registerAuthCommands(program);
 registerHooksCommands(program);
 registerIntentCommands(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codacy/verity-cli",
-  "version": "0.25.0-experimental.ed0c319",
+  "version": "0.26.0-experimental.d7dfc00",
   "description": "CLI for Verity quality gate service",
   "homepage": "https://verity.md",
   "repository": {