@yawlabs/ctxlint 0.6.0 → 0.7.0

package/dist/index.js

@@ -2,8 +2,8 @@
 
 // src/index.ts
 if (process.argv.includes("--mcp-server")) {
-  await import("./server-4SC5VMA7.js");
+  await import("./server-ADUSCPPU.js");
 } else {
-  const { runCli } = await import("./cli-XQVUFK2D.js");
+  const { runCli } = await import("./cli-7DNRBGDO.js");
   await runCli();
 }

package/dist/mcp/server.js

@@ -223,20 +223,20 @@ async function scanForMcpConfigs(projectRoot) {
 async function scanGlobalMcpConfigs() {
   const found = [];
   const seen = /* @__PURE__ */ new Set();
-  const home = process.env.HOME || process.env.USERPROFILE || "";
+  const home2 = process.env.HOME || process.env.USERPROFILE || "";
   const globalPaths = [
-    path2.join(home, ".claude.json"),
-    path2.join(home, ".claude", "settings.json"),
-    path2.join(home, ".cursor", "mcp.json"),
-    path2.join(home, ".codeium", "windsurf", "mcp_config.json"),
-    path2.join(home, ".aws", "amazonq", "mcp.json")
+    path2.join(home2, ".claude.json"),
+    path2.join(home2, ".claude", "settings.json"),
+    path2.join(home2, ".cursor", "mcp.json"),
+    path2.join(home2, ".codeium", "windsurf", "mcp_config.json"),
+    path2.join(home2, ".aws", "amazonq", "mcp.json")
   ];
   if (process.platform === "darwin") {
     globalPaths.push(
-      path2.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+      path2.join(home2, "Library", "Application Support", "Claude", "claude_desktop_config.json")
     );
   } else if (process.platform === "win32") {
-    const appData = process.env.APPDATA || path2.join(home, "AppData", "Roaming");
+    const appData = process.env.APPDATA || path2.join(home2, "AppData", "Roaming");
     globalPaths.push(path2.join(appData, "Claude", "claude_desktop_config.json"));
   }
   for (const filePath of globalPaths) {
@@ -252,7 +252,7 @@ async function scanGlobalMcpConfigs() {
     const target = symlink ? readSymlinkTarget(normalized) : void 0;
     found.push({
       absolutePath: normalized,
-      relativePath: "~/" + path2.relative(home, normalized).replace(/\\/g, "/"),
+      relativePath: "~/" + path2.relative(home2, normalized).replace(/\\/g, "/"),
       isSymlink: symlink,
       symlinkTarget: target,
       type: "mcp-config"
@@ -2311,9 +2311,494 @@ async function checkMcpRedundancy(configs) {
   return issues;
 }
 
+// src/core/session-scanner.ts
+import { readFile as readFile2, readdir, stat } from "fs/promises";
+import { dirname as dirname2, join as join4, resolve as resolve4 } from "path";
+import { existsSync } from "fs";
+import { simpleGit as simpleGit2 } from "simple-git";
+
+// src/core/session-parser.ts
+import { readFile } from "fs/promises";
+var PATH_PATTERN2 = /(?:^|\s|['"`(])([.~/][^\s'"`),;:!?]+)/g;
+function decodeProjectDir(dirName) {
+  const parts = dirName.split("--");
+  if (parts.length <= 1) return dirName;
+  if (parts[0].length === 1 && /^[A-Z]$/i.test(parts[0])) {
+    return parts[0] + ":/" + parts.slice(1).join("/");
+  }
+  return "/" + parts.join("/");
+}
+function extractPaths(content) {
+  const paths = [];
+  for (const match of content.matchAll(PATH_PATTERN2)) {
+    const p = match[1].replace(/[)}\]]+$/, "");
+    if (p.length > 2 && !p.startsWith("http") && !p.startsWith("//")) {
+      paths.push(p);
+    }
+  }
+  return [...new Set(paths)];
+}
+function parseFrontmatter2(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return { body: content };
+  }
+  const endIdx = lines.indexOf("---", 1);
+  if (endIdx === -1) {
+    return { body: content };
+  }
+  const frontmatter = {};
+  for (let i = 1; i < endIdx; i++) {
+    const line = lines[i];
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      frontmatter[key] = value;
+    }
+  }
+  return {
+    name: frontmatter["name"],
+    description: frontmatter["description"],
+    type: frontmatter["type"],
+    body: lines.slice(endIdx + 1).join("\n")
+  };
+}
+async function parseMemoryFile(filePath, projectDir) {
+  const content = await readFile(filePath, "utf-8");
+  const { name, description, type, body } = parseFrontmatter2(content);
+  const referencedPaths = extractPaths(body);
+  return {
+    filePath,
+    projectDir,
+    name,
+    description,
+    type,
+    content: body,
+    referencedPaths
+  };
+}
+
+// src/core/session-scanner.ts
+var home = process.env.HOME || process.env.USERPROFILE || "";
+var AGENT_DIRS = [
+  { provider: "claude-code", dir: join4(home, ".claude"), historyFile: "history.jsonl" },
+  { provider: "codex-cli", dir: join4(home, ".codex"), historyFile: "history.jsonl" },
+  { provider: "vibe-cli", dir: join4(home, ".vibe") },
+  {
+    provider: "amazon-q",
+    dir: join4(home, ".aws", "amazonq")
+  },
+  {
+    provider: "goose",
+    dir: process.platform === "win32" ? join4(process.env.APPDATA || "", "Block", "goose") : join4(home, ".config", "goose")
+  },
+  { provider: "continue", dir: join4(home, ".continue") },
+  {
+    provider: "windsurf",
+    dir: join4(home, ".windsurf")
+  }
+];
+function detectProviders() {
+  return AGENT_DIRS.filter((a) => existsSync(a.dir)).map((a) => a.provider);
+}
+async function parseJsonlFiltered(filePath, filter) {
+  if (!existsSync(filePath)) return [];
+  const content = await readFile2(filePath, "utf-8");
+  const results = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      const result = filter(parsed);
+      if (result) results.push(result);
+    } catch {
+    }
+  }
+  return results;
+}
+async function readClaudeHistory() {
+  const historyPath = join4(home, ".claude", "history.jsonl");
+  return parseJsonlFiltered(historyPath, (entry) => {
+    if (!entry.display || !entry.project) return null;
+    return {
+      display: entry.display,
+      timestamp: entry.timestamp || 0,
+      project: entry.project.replace(/\\/g, "/"),
+      sessionId: entry.sessionId || "",
+      provider: "claude-code"
+    };
+  });
+}
+async function readCodexHistory() {
+  const historyPath = join4(home, ".codex", "history.jsonl");
+  return parseJsonlFiltered(historyPath, (entry) => {
+    if (!entry.display && !entry.command) return null;
+    return {
+      display: entry.display || entry.command || "",
+      timestamp: entry.timestamp || 0,
+      project: (entry.project || entry.cwd || "").replace(/\\/g, "/"),
+      sessionId: entry.sessionId || "",
+      provider: "codex-cli"
+    };
+  });
+}
+async function readClaudeMemories() {
+  const projectsDir = join4(home, ".claude", "projects");
+  if (!existsSync(projectsDir)) return [];
+  const memories = [];
+  const projectDirs = await readdir(projectsDir).catch(() => []);
+  for (const projDir of projectDirs) {
+    const memoryDir = join4(projectsDir, projDir, "memory");
+    if (!existsSync(memoryDir)) continue;
+    const decodedPath = decodeProjectDir(projDir);
+    const files = await readdir(memoryDir).catch(() => []);
+    for (const file of files) {
+      if (!file.endsWith(".md") || file === "MEMORY.md") continue;
+      try {
+        const entry = await parseMemoryFile(join4(memoryDir, file), decodedPath);
+        memories.push(entry);
+      } catch {
+      }
+    }
+  }
+  return memories;
+}
+function detectAiderInSiblings(siblings) {
+  for (const sib of siblings) {
+    if (existsSync(join4(sib.path, ".aider.chat.history.md"))) {
+      return "aider";
+    }
+  }
+  return null;
+}
+async function detectSiblings(projectRoot) {
+  const parentDir = dirname2(resolve4(projectRoot));
+  const siblings = [];
+  let entries;
+  try {
+    entries = await readdir(parentDir);
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    const fullPath = join4(parentDir, entry);
+    const entryPath = resolve4(fullPath);
+    if (entryPath === resolve4(projectRoot)) continue;
+    try {
+      const s = await stat(fullPath);
+      if (!s.isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (entry.startsWith(".") || entry === "node_modules") continue;
+    const isProject = existsSync(join4(fullPath, ".git")) || existsSync(join4(fullPath, "package.json")) || existsSync(join4(fullPath, "Cargo.toml")) || existsSync(join4(fullPath, "go.mod")) || existsSync(join4(fullPath, "pyproject.toml"));
+    if (!isProject) continue;
+    const sibling = {
+      path: entryPath.replace(/\\/g, "/"),
+      name: entry
+    };
+    try {
+      const git = simpleGit2(fullPath);
+      const remotes = await git.getRemotes(true);
+      const origin = remotes.find((r) => r.name === "origin");
+      if (origin?.refs?.fetch) {
+        sibling.gitRemoteUrl = origin.refs.fetch;
+        const orgMatch = origin.refs.fetch.match(/github\.com[:/]([^/]+)\//);
+        if (orgMatch) sibling.gitOrg = orgMatch[1];
+      }
+    } catch {
+    }
+    siblings.push(sibling);
+  }
+  if (siblings.length > 50) {
+    const currentGit = simpleGit2(projectRoot);
+    let currentOrg;
+    try {
+      const remotes = await currentGit.getRemotes(true);
+      const origin = remotes.find((r) => r.name === "origin");
+      const orgMatch = origin?.refs?.fetch?.match(/github\.com[:/]([^/]+)\//);
+      if (orgMatch) currentOrg = orgMatch[1];
+    } catch {
+    }
+    if (currentOrg) {
+      return siblings.filter((s) => s.gitOrg === currentOrg);
+    }
+  }
+  return siblings;
+}
+async function scanSessionData(projectRoot) {
+  const providers = detectProviders();
+  const historyPromises = [];
+  if (providers.includes("claude-code")) historyPromises.push(readClaudeHistory());
+  if (providers.includes("codex-cli")) historyPromises.push(readCodexHistory());
+  const [histories, memories, siblings] = await Promise.all([
+    Promise.all(historyPromises).then((arrays) => arrays.flat()),
+    providers.includes("claude-code") ? readClaudeMemories() : Promise.resolve([]),
+    detectSiblings(projectRoot)
+  ]);
+  const aider = detectAiderInSiblings(siblings);
+  if (aider && !providers.includes("aider")) {
+    providers.push("aider");
+  }
+  return {
+    history: histories,
+    memories,
+    siblings,
+    currentProject: resolve4(projectRoot).replace(/\\/g, "/"),
+    providers
+  };
+}
+
+// src/core/checks/session/missing-secret.ts
+import { resolve as resolve5 } from "path";
+var SECRET_SET_PATTERN = /gh\s+secret\s+set\s+(\S+)\s+(?:--repo\s+(\S+)|.*-b\s+)/;
+var SECRET_SET_SIMPLE = /gh\s+secret\s+set\s+(\S+)/;
+async function checkMissingSecret(ctx) {
+  const issues = [];
+  const secrets = [];
+  for (const entry of ctx.history) {
+    const match = entry.display.match(SECRET_SET_PATTERN) || entry.display.match(SECRET_SET_SIMPLE);
+    if (!match) continue;
+    secrets.push({
+      name: match[1],
+      repo: match[2],
+      project: entry.project
+    });
+  }
+  if (secrets.length === 0) return issues;
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of secrets) {
+    if (!byName.has(s.name)) byName.set(s.name, /* @__PURE__ */ new Set());
+    byName.get(s.name).add(s.project);
+    if (s.repo) byName.get(s.name).add(s.repo);
+  }
+  const currentNorm = resolve5(ctx.currentProject).replace(/\\/g, "/");
+  for (const [secretName, projects] of byName) {
+    const currentHas = [...projects].some(
+      (p) => p.includes(currentNorm) || currentNorm.includes(p.replace(/\\/g, "/")) || p.includes(resolve5(ctx.currentProject).split(/[/\\]/).pop() || "")
+    );
+    if (currentHas) continue;
+    const siblingMatches = ctx.siblings.filter(
+      (sib) => [...projects].some(
+        (p) => p.replace(/\\/g, "/").includes(sib.name) || p.includes(sib.path)
+      )
+    );
+    if (siblingMatches.length >= 2) {
+      const sibNames = siblingMatches.map((s) => s.name).join(", ");
+      issues.push({
+        severity: "error",
+        check: "session-missing-secret",
+        ruleId: "session/missing-secret",
+        line: 0,
+        message: `GitHub secret "${secretName}" is set on ${siblingMatches.length} sibling repos (${sibNames}) but not on this project`,
+        suggestion: `Run: gh secret set ${secretName} --repo <owner>/<repo>`,
+        detail: `Found in agent history: ${siblingMatches.length} sibling repos have this secret configured`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/core/checks/session/diverged-file.ts
+import { readFile as readFile3 } from "fs/promises";
+import { join as join5 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var CANONICAL_FILES = [
+  "release.sh",
+  ".github/workflows/ci.yml",
+  ".github/workflows/release.yml",
+  "biome.json",
+  ".prettierrc",
+  ".eslintrc.json",
+  "tsconfig.json",
+  ".gitignore"
+];
+function calculateOverlap(a, b) {
+  const linesA = a.split("\n").map((l) => l.trim()).filter((l) => l.length > 3);
+  const linesB = new Set(
+    b.split("\n").map((l) => l.trim()).filter((l) => l.length > 3)
+  );
+  if (linesA.length === 0 && linesB.size === 0) return 1;
+  if (linesA.length === 0 || linesB.size === 0) return 0;
+  let matches = 0;
+  for (const line of linesA) {
+    if (linesB.has(line)) matches++;
+  }
+  return matches / Math.max(linesA.length, linesB.size);
+}
+async function checkDivergedFile(ctx) {
+  const issues = [];
+  for (const fileName of CANONICAL_FILES) {
+    const currentPath = join5(ctx.currentProject, fileName);
+    if (!existsSync2(currentPath)) continue;
+    let currentContent;
+    try {
+      currentContent = await readFile3(currentPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const diverged = [];
+    for (const sib of ctx.siblings) {
+      const sibPath = join5(sib.path, fileName);
+      if (!existsSync2(sibPath)) continue;
+      try {
+        const sibContent = await readFile3(sibPath, "utf-8");
+        const overlap = calculateOverlap(currentContent, sibContent);
+        if (overlap >= 0.2 && overlap < 0.9) {
+          diverged.push({ sibling: sib.name, overlap: Math.round(overlap * 100) });
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (diverged.length > 0) {
+      const details = diverged.map((d) => `${d.sibling} (${d.overlap}% overlap)`).join(", ");
+      issues.push({
+        severity: "warning",
+        check: "session-diverged-file",
+        ruleId: "session/diverged-file",
+        line: 0,
+        message: `${fileName} has diverged from sibling repos: ${details}`,
+        suggestion: `Compare with sibling versions to identify unintentional drift`,
+        detail: `Files with the same name across sibling repos should be kept in sync when they serve the same purpose`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/core/checks/session/missing-workflow.ts
+import { readdir as readdir2 } from "fs/promises";
+import { join as join6 } from "path";
+import { existsSync as existsSync3 } from "fs";
+async function checkMissingWorkflow(ctx) {
+  const issues = [];
+  const currentWorkflowDir = join6(ctx.currentProject, ".github", "workflows");
+  if (!existsSync3(join6(ctx.currentProject, ".github"))) return issues;
+  const currentWorkflows = /* @__PURE__ */ new Set();
+  if (existsSync3(currentWorkflowDir)) {
+    try {
+      const files = await readdir2(currentWorkflowDir);
+      for (const f of files) {
+        if (f.endsWith(".yml") || f.endsWith(".yaml")) currentWorkflows.add(f);
+      }
+    } catch {
+    }
+  }
+  const workflowMap = /* @__PURE__ */ new Map();
+  for (const sib of ctx.siblings) {
+    const sibWorkflowDir = join6(sib.path, ".github", "workflows");
+    if (!existsSync3(sibWorkflowDir)) continue;
+    try {
+      const files = await readdir2(sibWorkflowDir);
+      for (const f of files) {
+        if (!(f.endsWith(".yml") || f.endsWith(".yaml"))) continue;
+        if (!workflowMap.has(f)) workflowMap.set(f, []);
+        workflowMap.get(f).push(sib.name);
+      }
+    } catch {
+      continue;
+    }
+  }
+  for (const [workflow, siblings] of workflowMap) {
+    if (currentWorkflows.has(workflow)) continue;
+    if (siblings.length < 2) continue;
+    const sibNames = siblings.join(", ");
+    issues.push({
+      severity: "warning",
+      check: "session-missing-workflow",
+      ruleId: "session/missing-workflow",
+      line: 0,
+      message: `GitHub Actions workflow "${workflow}" exists in ${siblings.length} sibling repos (${sibNames}) but not in this project`,
+      suggestion: `Consider adding .github/workflows/${workflow} for consistency`,
+      detail: `Sibling repos with this workflow: ${sibNames}`
+    });
+  }
+  return issues;
+}
+
+// src/core/checks/session/stale-memory.ts
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve6, isAbsolute } from "path";
+async function checkStaleMemory(ctx) {
+  const issues = [];
+  const currentNorm = ctx.currentProject.replace(/\\/g, "/");
+  const projectMemories = ctx.memories.filter(
+    (m) => m.projectDir.replace(/\\/g, "/") === currentNorm
+  );
+  for (const mem of projectMemories) {
+    const brokenPaths = [];
+    for (const ref of mem.referencedPaths) {
+      const fullPath = isAbsolute(ref) ? ref : resolve6(ctx.currentProject, ref);
+      if (!existsSync4(fullPath)) {
+        brokenPaths.push(ref);
+      }
+    }
+    if (brokenPaths.length > 0) {
+      const name = mem.name || mem.filePath.split(/[/\\]/).pop() || "unknown";
+      issues.push({
+        severity: "info",
+        check: "session-stale-memory",
+        ruleId: "session/stale-memory",
+        line: 0,
+        message: `Memory "${name}" references ${brokenPaths.length} path(s) that no longer exist: ${brokenPaths.join(", ")}`,
+        suggestion: `Update or remove the memory file: ${mem.filePath}`,
+        detail: `Memory files with broken path references may cause the AI agent to follow stale instructions`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/core/checks/session/duplicate-memory.ts
+function calculateLineOverlap2(a, b) {
+  const linesA = a.split("\n").map((l) => l.trim()).filter((l) => l.length > 5);
+  const linesB = new Set(
+    b.split("\n").map((l) => l.trim()).filter((l) => l.length > 5)
+  );
+  if (linesA.length === 0 || linesB.size === 0) return 0;
+  let matches = 0;
+  for (const line of linesA) {
+    if (linesB.has(line)) matches++;
+  }
+  return matches / Math.max(linesA.length, linesB.size);
+}
+async function checkDuplicateMemory(ctx) {
+  const issues = [];
+  const reported = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ctx.memories.length; i++) {
+    for (let j = i + 1; j < ctx.memories.length; j++) {
+      const a = ctx.memories[i];
+      const b = ctx.memories[j];
+      if (a.projectDir.replace(/\\/g, "/") === b.projectDir.replace(/\\/g, "/")) continue;
+      if (a.content.length < 50 || b.content.length < 50) continue;
+      const overlap = calculateLineOverlap2(a.content, b.content);
+      if (overlap < 0.6) continue;
+      const pairKey = [a.filePath, b.filePath].sort().join("::");
+      if (reported.has(pairKey)) continue;
+      reported.add(pairKey);
+      const nameA = a.name || a.filePath.split(/[/\\]/).pop() || "unknown";
+      const nameB = b.name || b.filePath.split(/[/\\]/).pop() || "unknown";
+      const projA = a.projectDir.split(/[/\\]/).pop() || a.projectDir;
+      const projB = b.projectDir.split(/[/\\]/).pop() || b.projectDir;
+      issues.push({
+        severity: "info",
+        check: "session-duplicate-memory",
+        ruleId: "session/duplicate-memory",
+        line: 0,
+        message: `Memory "${nameA}" (${projA}) and "${nameB}" (${projB}) have ${Math.round(overlap * 100)}% overlap`,
+        suggestion: `Consider consolidating into a shared memory or removing the duplicate`,
+        detail: `Near-duplicate memories across projects waste context and may drift out of sync`
+      });
+    }
+  }
+  return issues;
+}
+
 // src/version.ts
 function loadVersion() {
-  if (true) return "0.6.0";
+  if (true) return "0.7.0";
   const fs6 = __require("fs");
   const path9 = __require("path");
   const pkgPath = path9.resolve(__dirname, "../package.json");
@@ -2342,13 +2827,24 @@ var ALL_MCP_CHECKS = [
   "mcp-consistency",
   "mcp-redundancy"
 ];
+var ALL_SESSION_CHECKS = [
+  "session-missing-secret",
+  "session-diverged-file",
+  "session-missing-workflow",
+  "session-stale-memory",
+  "session-duplicate-memory"
+];
 function hasMcpChecks(checks) {
   return checks.some((c) => c.startsWith("mcp-"));
 }
+function hasSessionChecks(checks) {
+  return checks.some((c) => c.startsWith("session-"));
+}
 async function runAudit(projectRoot, activeChecks, options = {}) {
   const fileResults = [];
-  const shouldRunContextChecks = !options.mcpOnly;
+  const shouldRunContextChecks = !options.mcpOnly && !options.sessionOnly;
   const shouldRunMcpChecks = options.mcp || options.mcpGlobal || options.mcpOnly || hasMcpChecks(activeChecks);
+  const shouldRunSessionChecks = options.session || options.sessionOnly || hasSessionChecks(activeChecks);
   if (shouldRunContextChecks) {
     const discovered = await scanForContextFiles(projectRoot, {
       depth: options.depth,
@@ -2450,6 +2946,37 @@ async function runAudit(projectRoot, activeChecks, options = {}) {
       }
     }
   }
+  if (shouldRunSessionChecks) {
+    const activeSessionChecks = activeChecks.filter(
+      (c) => c.startsWith("session-")
+    );
+    const sessionChecksToRun = activeSessionChecks.length > 0 ? activeSessionChecks : options.session || options.sessionOnly ? ALL_SESSION_CHECKS : [];
+    if (sessionChecksToRun.length > 0) {
+      const sessionCtx = await scanSessionData(projectRoot);
+      const sessionPromises = [];
+      if (sessionChecksToRun.includes("session-missing-secret"))
+        sessionPromises.push(checkMissingSecret(sessionCtx));
+      if (sessionChecksToRun.includes("session-diverged-file"))
+        sessionPromises.push(checkDivergedFile(sessionCtx));
+      if (sessionChecksToRun.includes("session-missing-workflow"))
+        sessionPromises.push(checkMissingWorkflow(sessionCtx));
+      if (sessionChecksToRun.includes("session-stale-memory"))
+        sessionPromises.push(checkStaleMemory(sessionCtx));
+      if (sessionChecksToRun.includes("session-duplicate-memory"))
+        sessionPromises.push(checkDuplicateMemory(sessionCtx));
+      const sessionResults = await Promise.all(sessionPromises);
+      const sessionIssues = sessionResults.flat();
+      if (sessionIssues.length > 0) {
+        fileResults.push({
+          path: "~/.claude/ (session audit)",
+          isSymlink: false,
+          tokens: 0,
+          lines: 0,
+          issues: sessionIssues
+        });
+      }
+    }
+  }
   let estimatedWaste = 0;
   for (const fr of fileResults) {
     for (const issue of fr.issues) {
@@ -2551,7 +3078,12 @@ var checkEnum = z.enum([
   "mcp-env",
   "mcp-urls",
   "mcp-consistency",
-  "mcp-redundancy"
+  "mcp-redundancy",
+  "session-missing-secret",
+  "session-diverged-file",
+  "session-missing-workflow",
+  "session-stale-memory",
+  "session-duplicate-memory"
 ]);
 var server = new McpServer({
   name: "ctxlint",
@@ -2760,5 +3292,39 @@ server.tool(
     }
   }
 );
+server.tool(
+  "ctxlint_session_audit",
+  "Audit AI agent session data for cross-project consistency. Checks for missing GitHub secrets, diverged config files, missing workflows, stale memory entries, and duplicate memories across sibling repositories.",
+  {
+    projectPath: z.string().optional().describe("Path to the project root. Defaults to current working directory."),
+    checks: z.array(checkEnum).optional().describe("Specific session checks to run (default: all session-* checks).")
+  },
+  {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: true
+  },
+  async ({ projectPath, checks }) => {
+    const root = path8.resolve(projectPath || process.cwd());
+    const activeChecks = checks || ALL_SESSION_CHECKS;
+    try {
+      const result = await runAudit(root, activeChecks, {
+        session: true,
+        sessionOnly: true
+      });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: msg }) }],
+        isError: true
+      };
+    } finally {
+      freeEncoder();
+      resetGit();
+    }
+  }
+);
 var transport = new StdioServerTransport();
 await server.connect(transport);