getprismo 0.1.9 → 0.1.11

package/README.md

@@ -41,6 +41,7 @@ after you code      npx getprismo cc timeline
 - missing `.claudeignore` / `.cursorignore` (the biggest single fix for most repos)
 - lockfiles entering context (`package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`)
 - generated artifacts leaking in (`__pycache__`, `dist/`, `coverage/`, `.next/`)
+- operational source-stream dumps leaking in (`events/`, `source-streams/`, inbox/calendar/GitHub JSONL exports)
 - oversized instruction files (`CLAUDE.md` or `AGENTS.md` over 500 tokens)
 - tool output dominating sessions (repeated reads, large command output)
 - long-running sessions with stale context accumulation
@@ -394,7 +395,9 @@ prismo-dev-report.md                       full diagnostic report
 
 if an existing `.claudeignore` or `.cursorignore` already covers prismo's recommendations, doctor skips the suggested ignore file instead of creating redundant noise. the default recommendations include common project state, local db, export, credential, and token patterns such as `*_state.json`, `*_tokens.json`, `*_export.json`, `*.sqlite`, `models/`, and `state-backups/`.
 
-backend and frontend summaries include load-bearing candidates ranked by lightweight reference signals plus file size, not just directory listings.
+backend and frontend summaries include load-bearing candidates ranked by import references, text-reference signals, recent git touches when available, and file size, not just directory listings.
+
+prismo also flags source-stream dumps separately from normal build artifacts. large inbox/calendar/github/event payload files are treated as operational noise because they often get summarized once, written near the repo, and then accidentally re-read by later coding sessions.
 
 what doctor never touches:
 
@@ -656,7 +659,7 @@ then your team can run `npm run ai:doctor` without remembering the full command.
 - openai codex
 - cursor
 - any tool that respects `.claudeignore` or `.cursorignore`
-- any repo (node, python, go, rust, monorepos, whatever)
+- any repo (node, python, go, rust, vue, svelte, astro, monorepos, whatever)
 
 ---
 

package/lib/prismo-dev/constants.js

@@ -84,6 +84,10 @@ const SOURCE_EXTENSIONS = new Set([
   ".html",
   ".vue",
   ".svelte",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
 ]);
 
 const INSTRUCTION_FILES = [
@@ -120,8 +124,15 @@ const DEFAULT_CLAUDEIGNORE = [
   "package-lock.json",
   "yarn.lock",
   "pnpm-lock.yaml",
+  "bun.lockb",
   "test-results/",
   "playwright-report/",
+  "events/",
+  "event-dumps/",
+  "session-dumps/",
+  "source-streams/",
+  "inbox-dumps/",
+  "calendar-dumps/",
   "models/",
   "state-backups/",
   "backups/",
@@ -158,6 +169,7 @@ const GENERATED_ARTIFACT_PATTERNS = [
   /(^|\/)coverage\//,
   /(^|\/)playwright-report\//,
   /(^|\/)test-results\//,
+  /(^|\/)(events|event-dumps|session-dumps|source-streams|inbox-dumps|calendar-dumps)\//,
   /(^|\/)__pycache__\//,
   /(^|\/)\.pytest_cache\//,
   /(^|\/)\.cache\//,

package/lib/prismo-dev/context-optimize.js

@@ -10,6 +10,7 @@ module.exports = function createContextOptimize(deps) {
     color,
     writeGeneratedFile,
   } = deps;
+  const { execFileSync } = require("child_process");
 
 function findRepoFiles(result, predicate, limit = 40) {
   return result.files
@@ -25,6 +26,11 @@ function detectFrameworks(root, result) {
     const deps = { ...(pkg && pkg.dependencies), ...(pkg && pkg.devDependencies) };
     if (deps.next) frameworks.add("Next.js");
     if (deps.react) frameworks.add("React");
+    if (deps.vue || deps["@vue/runtime-core"]) frameworks.add("Vue");
+    if (deps.svelte || deps["@sveltejs/kit"]) frameworks.add(deps["@sveltejs/kit"] ? "SvelteKit" : "Svelte");
+    if (deps["solid-js"]) frameworks.add("Solid");
+    if (deps.astro) frameworks.add("Astro");
+    if (deps.nuxt) frameworks.add("Nuxt");
     if (deps.express) frameworks.add("Express");
     if (deps["@nestjs/core"]) frameworks.add("NestJS");
     if (deps.prisma || deps["@prisma/client"]) frameworks.add("Prisma");
@@ -74,6 +80,11 @@ function detectFrameworks(root, result) {
   if ([...textFiles.keys()].some((rel) => rel.includes("prisma/schema.prisma"))) frameworks.add("Prisma");
   if ([...textFiles.keys()].some((rel) => rel.includes("next.config."))) frameworks.add("Next.js");
   if ([...textFiles.keys()].some((rel) => rel.includes("vite.config."))) frameworks.add("Vite");
+  if ([...textFiles.keys()].some((rel) => rel.includes("svelte.config."))) frameworks.add("SvelteKit");
+  if ([...textFiles.keys()].some((rel) => rel.includes("astro.config."))) frameworks.add("Astro");
+  if ([...textFiles.keys()].some((rel) => rel.includes("nuxt.config."))) frameworks.add("Nuxt");
+  if ([...textFiles.keys()].some((rel) => rel.endsWith(".vue"))) frameworks.add("Vue");
+  if ([...textFiles.keys()].some((rel) => rel.endsWith(".svelte"))) frameworks.add("Svelte");
   if ([...textFiles.keys()].some((rel) => rel.includes("tailwind.config."))) frameworks.add("Tailwind");
   if ([...textFiles.keys()].some((rel) => rel.endsWith("tsconfig.json"))) frameworks.add("TypeScript");
   if ([...textFiles.keys()].some((rel) => rel.includes("alembic/") || rel.endsWith("alembic.ini"))) frameworks.add("Alembic");
@@ -108,6 +119,11 @@ function detectEntrypoints(result) {
     "src/app/page.tsx",
     "src/main.tsx",
     "src/index.tsx",
+    "src/App.vue",
+    "src/App.svelte",
+    "src/routes/+page.svelte",
+    "src/pages/index.astro",
+    "app.vue",
     "server.js",
     "index.js",
     "docker/docker-compose.yml",
@@ -172,12 +188,18 @@ function detectBackendPaths(result) {
 }
 
 function detectFrontendPaths(result) {
+  const appSurface = /(^|\/)(frontend\/)?src\/(app|pages|routes)\//;
+  const appFile = /(^|\/)(frontend\/)?src\/(App|main|index)\.(jsx?|tsx?|vue|svelte)$/;
+  const componentFile = /(^|\/)(frontend\/)?src\/(components|ui|widgets)\//;
+  const apiFile = /(^|\/)(frontend\/)?src\/(lib|hooks|composables|stores|services|api)\/.*(api|client|query|fetch|request|finops)/;
+  const stylingFile = /tailwind\.config|globals\.css|app\.css|\.module\.css|\.scss$|(^|\/)(frontend\/)?src\/styles?\//;
+  const stateFile = /providers?\.(tsx?|jsx?)|react-query|use[A-Z].*\.(ts|tsx|js|jsx)|(^|\/)(stores?|state|pinia|zustand|redux)\//;
   return {
-    app: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/frontend\/src\/app\//.test(rel) || /frontend\/src\/App\.[jt]sx?$/.test(rel) || /src\/App\.[jt]sx?$/.test(rel) || /src\/app\//.test(rel) || /apps\/[^/]+\/app\//.test(rel) || /apps\/[^/]+\/src\/app\//.test(rel)), 24).map((f) => f.path),
-    components: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/frontend\/src\/components\//.test(rel) || /src\/components\//.test(rel) || /apps\/[^/]+\/.*components\//.test(rel) || /packages\/[^/]+\/.*components\//.test(rel)), 20).map((f) => f.path),
-    apiClient: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/frontend\/src\/(lib|hooks)\/.*(api|client|query|finops)/.test(rel) || /src\/(lib|hooks)\/.*(api|client|query)/.test(rel)), 20).map((f) => f.path),
-    styling: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/tailwind\.config|globals\.css|\.module\.css|frontend\/src\/app\/globals/.test(rel)), 20).map((f) => f.path),
-    state: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (/providers\.tsx|react-query|use[A-Z].*\.ts/.test(rel)), 20).map((f) => f.path),
+    app: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (appSurface.test(rel) || appFile.test(rel) || /(^|\/)app\.vue$/.test(rel) || /apps\/[^/]+\/(app|pages|routes|src\/app|src\/pages|src\/routes)\//.test(rel)), 24).map((f) => f.path),
+    components: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (componentFile.test(rel) || /apps\/[^/]+\/.*(components|ui|widgets)\//.test(rel) || /packages\/[^/]+\/.*(components|ui|widgets)\//.test(rel)), 24).map((f) => f.path),
+    apiClient: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && (apiFile.test(rel) || /apps\/[^/]+\/.*(lib|hooks|composables|services|api)\/.*(api|client|query|fetch|request)/.test(rel)), 24).map((f) => f.path),
+    styling: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && stylingFile.test(rel), 24).map((f) => f.path),
+    state: findRepoFiles(result, (rel) => !isNonSourcePath(rel) && stateFile.test(rel), 24).map((f) => f.path),
   };
 }
 
@@ -193,7 +215,7 @@ function createOptimizeContext(rootDir = process.cwd(), scope = null) {
     frameworks.some((name) => ["FastAPI", "Django", "Flask"].includes(name)) ||
     Boolean(backend.api.length || backend.services.length || backend.db.length || backend.auth.length);
   const frontendDetected = folders.includes("frontend") ||
-    frameworks.some((name) => ["Next.js", "React", "Vite"].includes(name)) ||
+    frameworks.some((name) => ["Next.js", "React", "Vite", "Vue", "Svelte", "SvelteKit", "Solid", "Astro", "Nuxt"].includes(name)) ||
     Boolean(frontend.app.length || frontend.components.length || frontend.apiClient.length || frontend.state.length);
   const warnings = [];
   if (scan.exposedLargeFiles.length) warnings.push(`${scan.exposedLargeFiles.length} exposed large file(s) may bloat AI context.`);
@@ -218,6 +240,7 @@ function createOptimizeContext(rootDir = process.cwd(), scope = null) {
     frontendDetected,
     backend,
     frontend,
+    gitActivity: getGitActivity(root),
     warnings,
     suggestions,
     estimatedContextReduction: scan.avoidableWaste,
@@ -230,20 +253,139 @@ function mdList(items, empty = "None detected.") {
   return items.map((item) => `- \`${item}\``).join("\n");
 }
 
-function topLoadBearing(root, files, allFiles, limit = 8) {
-  const textFiles = (allFiles || []).filter((file) => !file.ignored && file.kind !== "binary" && /\.(py|tsx?|jsx?)$/.test(file.path));
-  const corpus = textFiles.map((file) => `${file.path}\n${readIfText(path.join(root, file.path)) || ""}`);
+function moduleNameForPath(rel) {
+  return rel
+    .replace(/\.[^.]+$/, "")
+    .replace(/\/__init__$/, "")
+    .replace(/\/index$/, "")
+    .replace(/\//g, ".");
+}
+
+function basenameStem(rel) {
+  return path.basename(rel).replace(/\.[^.]+$/, "");
+}
+
+function extractPythonImports(text) {
+  const imports = new Set();
+  const importRe = /^\s*import\s+([a-zA-Z0-9_.,\s]+)/gm;
+  const fromRe = /^\s*from\s+([a-zA-Z0-9_.]+)\s+import\s+/gm;
+  let match;
+  while ((match = importRe.exec(text))) {
+    match[1].split(",").map((part) => part.trim().split(/\s+as\s+/)[0]).filter(Boolean).forEach((name) => imports.add(name));
+  }
+  while ((match = fromRe.exec(text))) imports.add(match[1]);
+  return imports;
+}
+
+function resolveJsImport(fromRel, specifier, sourcePaths) {
+  if (!specifier.startsWith(".")) return null;
+  const fromDir = path.posix.dirname(fromRel);
+  const base = path.posix.normalize(path.posix.join(fromDir, specifier));
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.jsx`,
+    `${base}/index.ts`,
+    `${base}/index.tsx`,
+    `${base}/index.js`,
+    `${base}/index.jsx`,
+  ];
+  return candidates.find((candidate) => sourcePaths.has(candidate)) || null;
+}
+
+function extractJsImports(fromRel, text, sourcePaths) {
+  const imports = new Set();
+  const importRe = /\bfrom\s+["']([^"']+)["']|import\s*\(\s*["']([^"']+)["']\s*\)|require\s*\(\s*["']([^"']+)["']\s*\)/g;
+  let match;
+  while ((match = importRe.exec(text))) {
+    const specifier = match[1] || match[2] || match[3];
+    const resolved = resolveJsImport(fromRel, specifier, sourcePaths);
+    if (resolved) imports.add(resolved);
+  }
+  return imports;
+}
+
+function getGitActivity(root) {
+  const activity = new Map();
+  try {
+    const output = execFileSync("git", ["-C", root, "log", "--since=180 days ago", "--name-only", "--format=%ct"], {
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    let currentTs = 0;
+    for (const rawLine of output.split(/\r?\n/)) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      if (/^\d{9,}$/.test(line)) {
+        currentTs = Number(line);
+        continue;
+      }
+      const rel = line.replace(/\\/g, "/");
+      const previous = activity.get(rel) || { touches: 0, lastTouched: 0 };
+      previous.touches += 1;
+      previous.lastTouched = Math.max(previous.lastTouched, currentTs);
+      activity.set(rel, previous);
+    }
+  } catch {
+    return activity;
+  }
+  return activity;
+}
+
+function formatGitActivity(activity) {
+  if (!activity || !activity.touches) return "no recent git touches";
+  const date = activity.lastTouched ? new Date(activity.lastTouched * 1000).toISOString().slice(0, 10) : "unknown date";
+  return `${activity.touches} recent git touch${activity.touches === 1 ? "" : "es"}, last ${date}`;
+}
+
+function topLoadBearing(root, files, allFiles, gitActivity, limit = 8) {
+  const textFiles = (allFiles || []).filter((file) => !file.ignored && file.kind !== "binary" && /\.(py|tsx?|jsx?|mjs|cjs|vue|svelte)$/.test(file.path));
+  const sourcePaths = new Set(textFiles.map((file) => file.path));
+  const pythonModuleToPath = new Map();
+  for (const file of textFiles.filter((candidate) => candidate.path.endsWith(".py"))) {
+    pythonModuleToPath.set(moduleNameForPath(file.path), file.path);
+    pythonModuleToPath.set(basenameStem(file.path), file.path);
+  }
+
+  const importRefs = new Map();
+  const textRefs = new Map();
+  const corpus = textFiles.map((file) => {
+    const text = readIfText(path.join(root, file.path), 512 * 1024) || "";
+    if (file.path.endsWith(".py")) {
+      for (const imported of extractPythonImports(text)) {
+        const target = pythonModuleToPath.get(imported) || pythonModuleToPath.get(imported.split(".").pop());
+        if (target && target !== file.path) importRefs.set(target, (importRefs.get(target) || 0) + 1);
+      }
+    } else if (/\.(tsx?|jsx?|mjs|cjs|vue|svelte)$/.test(file.path)) {
+      for (const target of extractJsImports(file.path, text, sourcePaths)) {
+        if (target !== file.path) importRefs.set(target, (importRefs.get(target) || 0) + 1);
+      }
+    }
+    return `${file.path}\n${text}`;
+  });
+
+  for (const file of files || []) {
+    const base = basenameStem(file.path);
+    const importName = base.replace(/[-.]/g, "_");
+    const refs = corpus.reduce((sum, text) => sum + (text.includes(base) || text.includes(importName) ? 1 : 0), 0);
+    textRefs.set(file.path, refs);
+  }
+
   return [...(files || [])]
     .filter((file) => !file.ignored && file.kind !== "binary")
     .map((file) => {
-      const base = path.basename(file.path).replace(/\.[^.]+$/, "");
-      const importName = base.replace(/[-.]/g, "_");
-      const refs = corpus.reduce((sum, text) => sum + (text.includes(base) || text.includes(importName) ? 1 : 0), 0);
-      return { file, refs };
+      const imports = importRefs.get(file.path) || 0;
+      const refs = textRefs.get(file.path) || 0;
+      const git = gitActivity.get(file.path) || { touches: 0, lastTouched: 0 };
+      const score = imports * 1000 + refs * 25 + Math.min(git.touches, 20) * 10 + Math.log10(file.size + 1);
+      return { file, imports, refs, git, score };
     })
-    .sort((a, b) => b.refs - a.refs || b.file.size - a.file.size)
+    .sort((a, b) => b.score - a.score || b.file.size - a.file.size)
     .slice(0, limit)
-    .map(({ file, refs }) => `${file.path} (${refs} reference signal${refs === 1 ? "" : "s"}, ${formatBytes(file.size)})`);
+    .map(({ file, imports, refs, git }) => `${file.path} (${imports} import ref${imports === 1 ? "" : "s"}, ${refs} text reference signal${refs === 1 ? "" : "s"}, ${formatGitActivity(git)}, ${formatBytes(file.size)})`);
 }
 
 function inferGaps(ctx) {
@@ -355,7 +497,7 @@ function renderArchitectureSummary(ctx) {
 }
 
 function renderBackendSummary(ctx) {
-  const backendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => file.path.endsWith(".py") && !isNonSourcePath(file.path)), ctx.scan.files, 8);
+  const backendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => file.path.endsWith(".py") && !isNonSourcePath(file.path)), ctx.scan.files, ctx.gitActivity, 8);
   return [
     "# Backend Summary",
     "",
@@ -399,7 +541,7 @@ function renderBackendSummary(ctx) {
 }
 
 function renderFrontendSummary(ctx) {
-  const frontendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => /\.(tsx?|jsx?)$/.test(file.path) && /(^|\/)(frontend|src|app|components|hooks)\//.test(file.path)), ctx.scan.files, 8);
+  const frontendCandidates = topLoadBearing(ctx.root, ctx.scan.files.filter((file) => /\.(tsx?|jsx?|mjs|cjs|vue|svelte)$/.test(file.path) && /(^|\/)(frontend|src|app|pages|routes|components|ui|hooks|composables|stores)\//.test(file.path)), ctx.scan.files, ctx.gitActivity, 8);
   return [
     "# Frontend Summary",
     "",

package/lib/prismo-dev/firewall.js

@@ -78,7 +78,15 @@ function buildBlockedContext(ctx) {
     "playwright-report/**",
     "test-results/**",
     "logs/**",
+    "events/**",
+    "event-dumps/**",
+    "session-dumps/**",
+    "source-streams/**",
+    "inbox-dumps/**",
+    "calendar-dumps/**",
     "**/*.log",
+    "**/*.jsonl",
+    "**/*.ndjson",
     "**/*.map",
     "**/__pycache__/**",
     "package-lock.json",

package/lib/prismo-dev/report.js

@@ -68,6 +68,13 @@ function renderTerminalReport(result, options = {}) {
   if (result.toolOutputRisk.exposedNoisyDirectories.length) lines.push(`- Exposed noisy dirs: ${result.toolOutputRisk.exposedNoisyDirectories.slice(0, 6).join(", ")}`);
   if (result.toolOutputRisk.exposedNoisyFiles.length) lines.push(`- Exposed noisy files: ${result.toolOutputRisk.exposedNoisyFiles.slice(0, 4).map((file) => file.path).join(", ")}`);
   lines.push("");
+  if (result.operationalNoise && result.operationalNoise.level !== "Low") {
+    lines.push(color("Operational Noise Risk", "bold", useColor));
+    lines.push(`- Level: ${result.operationalNoise.level}`);
+    lines.push(`- ${result.operationalNoise.summary}`);
+    result.operationalNoise.files.slice(0, 4).forEach((file) => lines.push(`- ${file.path}: ${file.signals.join(", ")}`));
+    lines.push("");
+  }
   lines.push(color("Prismo Proxy Tracking", "bold", useColor));
   lines.push("- Exact API tracking: available when traffic uses the Prismo OpenAI/Anthropic base URL");
   lines.push(`- Codex API/base-url mode: ${result.proxyTrackingReadiness.codingAgentBaseUrlMode.codex}`);
@@ -233,6 +240,18 @@ function renderMarkdownReport(result) {
     });
   }
   lines.push("");
+  lines.push("## Operational Source-Stream Noise");
+  lines.push("");
+  if (result.operationalNoise && result.operationalNoise.files.length) {
+    lines.push(`- Level: ${result.operationalNoise.level}`);
+    lines.push(`- ${result.operationalNoise.summary}`);
+    result.operationalNoise.files.slice(0, 20).forEach((file) => {
+      lines.push(`- \`${file.path}\` - ${formatBytes(file.sizeBytes)} - ${file.signals.join(", ")} - ~${file.estimatedTokensIfRead.toLocaleString()} tokens if read`);
+    });
+  } else {
+    lines.push("- No obvious inbox/calendar/GitHub/source-stream dumps detected.");
+  }
+  lines.push("");
   lines.push("## Prismo Proxy Tracking Readiness");
   lines.push("");
   lines.push("- Exact API tracking: available when app/tool traffic uses the Prismo OpenAI/Anthropic base URL.");

package/lib/prismo-dev/scan.js

@@ -364,6 +364,57 @@ function detectToolOutputRisk({ exposedLargeFiles, exposedHighRiskDirs, highRisk
   };
 }
 
+function detectOperationalNoise(files) {
+  const candidates = files
+    .filter((file) => !file.ignored && file.size >= 16 * 1024 && file.kind !== "binary")
+    .filter((file) => /\.(json|jsonl|ndjson|log|md|txt)$/i.test(file.path) || /(events?|inbox|calendar|github|issues?|heartbeat|poll|source-stream|session-dump|activity|notifications?)/i.test(file.path))
+    .slice(0, 120);
+  const findings = [];
+
+  for (const file of candidates) {
+    const text = readIfText(file.fullPath, 512 * 1024) || "";
+    if (!text) continue;
+    const signals = [];
+    const timestampCount = (text.match(/\b20\d{2}-\d{2}-\d{2}[T ][0-2]\d:/g) || []).length;
+    const emailCount = (text.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi) || []).length;
+    const eventKeyCount = (text.match(/"(event|type|timestamp|created_at|updated_at|attendees|organizer|sender|subject|body|issue|pull_request|repository|payload)"\s*:/gi) || []).length;
+    const markdownEventCount = (text.match(/\b(calendar|inbox|email|github|issue|pull request|notification|attendee|heartbeat|poll(ed|ing)?)\b/gi) || []).length;
+    const repeatedObjectCount = (text.match(/^\s*\{.*\}\s*$/gm) || []).length;
+
+    if (timestampCount >= 12) signals.push(`${timestampCount} timestamps`);
+    if (emailCount >= 8) signals.push(`${emailCount} email-like strings`);
+    if (eventKeyCount >= 30) signals.push(`${eventKeyCount} event-shaped JSON keys`);
+    if (markdownEventCount >= 20) signals.push(`${markdownEventCount} operational keywords`);
+    if (repeatedObjectCount >= 15) signals.push(`${repeatedObjectCount} JSONL-style objects`);
+
+    if (signals.length >= 2 || eventKeyCount >= 60 || (timestampCount >= 20 && markdownEventCount >= 15)) {
+      findings.push({
+        path: file.path,
+        sizeBytes: file.size,
+        estimatedTokensIfRead: estimateTokens(file.size),
+        signals: signals.slice(0, 4),
+      });
+    }
+  }
+
+  const estimatedExposureTokens = findings.reduce((sum, item) => sum + item.estimatedTokensIfRead, 0);
+  let level = "Low";
+  if (findings.length >= 3 || estimatedExposureTokens >= 150000) level = "High";
+  else if (findings.length || estimatedExposureTokens >= 25000) level = "Medium";
+
+  return {
+    level,
+    files: findings.slice(0, 12),
+    estimatedExposureTokens,
+    summary:
+      level === "High"
+        ? "Operational source-stream dumps may be leaking inbox/calendar/GitHub-style noise back into coding context."
+        : level === "Medium"
+          ? "Possible operational source-stream dumps detected; these can become second-order context leaks."
+          : "No obvious operational source-stream dumps detected.",
+  };
+}
+
 function buildProxyTrackingReadiness({ codexConfig, claudeConfig, realUsage }) {
   return {
     exactApiTracking: {
@@ -578,7 +629,7 @@ function addIssue(issues, severity, category, title, description, recommendation
   });
 }
 
-function buildRecommendations({ hasClaudeIgnore, gitignorePatterns, exposedHighRiskDirs, largeFiles, instructionFiles, claudeConfig, toolOutputRisk, agentReadiness }) {
+function buildRecommendations({ hasClaudeIgnore, gitignorePatterns, exposedHighRiskDirs, largeFiles, instructionFiles, claudeConfig, toolOutputRisk, operationalNoise, agentReadiness }) {
   const recs = [];
   if (!hasClaudeIgnore) {
     recs.push("Create .claudeignore with generated/cache folders and large artifacts excluded.");
@@ -595,6 +646,9 @@ function buildRecommendations({ hasClaudeIgnore, gitignorePatterns, exposedHighR
   if (toolOutputRisk && toolOutputRisk.level !== "Low") {
     recs.push("Use command-output filtering or narrower shell commands for noisy tests, logs, diffs, and generated reports.");
   }
+  if (operationalNoise && operationalNoise.level !== "Low") {
+    recs.push("Keep inbox/calendar/GitHub polling dumps out of coding-agent context; summarize them outside the repo or add them to AI ignore files.");
+  }
   if (instructionFiles.some((file) => file.isClaude && file.tokens > 1500)) {
     recs.push("Review CLAUDE.md for content that could move to linked docs; keep persistent instructions focused on durable rules.");
   }
@@ -665,7 +719,7 @@ function calculateReductionPercent(beforeTokens, afterTokens) {
 
 function chooseRecommendedScope(ctx) {
   if (ctx.scope) return ctx.scope;
-  if (ctx.frameworks.some((name) => ["Next.js", "React", "Vite"].includes(name))) return "frontend";
+  if (ctx.frameworks.some((name) => ["Next.js", "React", "Vite", "Vue", "Svelte", "SvelteKit", "Solid", "Astro", "Nuxt"].includes(name))) return "frontend";
   if (ctx.frameworks.some((name) => ["FastAPI", "Django", "Flask", "Python"].includes(name))) return "backend";
   return null;
 }
@@ -720,6 +774,7 @@ function toJsonPayload(result) {
     agentReadiness: result.agentReadiness,
     optimizationStack: result.optimizationStack,
     toolOutputRisk: result.toolOutputRisk,
+    operationalNoise: result.operationalNoise,
     proxyTrackingReadiness: result.proxyTrackingReadiness,
     suggestedClaudeIgnore: result.recommendedClaudeIgnore,
     suggestedCursorIgnore: result.recommendedCursorIgnore,
@@ -1010,6 +1065,7 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
   const optimizationStack = detectOptimizationStack(root, claudeConfig, codexConfig);
   const agentReadiness = detectAgentReadiness(root, claudeConfig, codexConfig, realUsage);
   const toolOutputRisk = detectToolOutputRisk({ exposedLargeFiles, exposedHighRiskDirs, highRiskDirs });
+  const operationalNoise = detectOperationalNoise(files);
   const proxyTrackingReadiness = buildProxyTrackingReadiness({ codexConfig, claudeConfig, realUsage });
 
   if (toolOutputRisk.level !== "Low") {
@@ -1026,6 +1082,20 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     );
   }
 
+  if (operationalNoise.level !== "Low") {
+    addIssue(
+      issues,
+      operationalNoise.level === "High" ? "high" : "medium",
+      "operational_noise",
+      `${operationalNoise.files.length} source-stream dump${operationalNoise.files.length === 1 ? "" : "s"} may leak into context`,
+      operationalNoise.files.slice(0, 5).map((file) => `${file.path} (${file.signals.join(", ")})`).join(", "),
+      "Do not feed raw inbox/calendar/GitHub/event dumps back into coding sessions; summarize externally or add them to .claudeignore/.cursorignore.",
+      operationalNoise.estimatedExposureTokens
+        ? `Likely avoidable token exposure: up to ~${operationalNoise.estimatedExposureTokens.toLocaleString()} tokens from operational noise files.`
+        : "Potential savings estimate: prevents source-stream dumps from becoming recurring context."
+    );
+  }
+
   if (optimizationStack.mcpServerTotal >= 8) {
     addIssue(
       issues,
@@ -1074,10 +1144,12 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
   const largeFileSuggestions = exposedLargeFiles
     .filter((file) => file.size >= 1024 * 1024 || ["log", "json", "minified", "lock/generated"].includes(file.kind))
     .map((file) => file.path);
+  const operationalNoiseSuggestions = operationalNoise.files.map((file) => file.path);
   const recommendedClaudeIgnore = Array.from(new Set([
     ...DEFAULT_CLAUDEIGNORE,
     ...gitignorePatterns.filter((line) => !line.startsWith("!")),
     ...largeFileSuggestions,
+    ...operationalNoiseSuggestions,
   ]));
   const recommendedCursorIgnore = Array.from(new Set([
     ...recommendedClaudeIgnore,
@@ -1094,6 +1166,7 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     instructionFiles,
     claudeConfig,
     toolOutputRisk,
+    operationalNoise,
     agentReadiness,
   });
   buildRealUsageRecommendations(realUsage).forEach((rec) => recommendations.push(rec));
@@ -1109,6 +1182,7 @@ function scanRepo(rootDir = process.cwd(), options = {}) {
     agentReadiness,
     optimizationStack,
     toolOutputRisk,
+    operationalNoise,
     proxyTrackingReadiness,
     frameworks,
     files,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",