@minhpnq1807/contextos 0.1.9 → 0.3.1

package/plugins/ctx/bin/on-stop.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
-import { readStdinJson, writeJson, failOpen, logDebug, pluginRuntimeFile } from "../lib/hook-io.js";
+import { readStdinJson, writeJson, failOpen, logDebug, pluginRuntimeFile, resolveHookCwd } from "../lib/hook-io.js";
 import { handleStopPayload } from "../lib/stop-hook.js";
 import { appendTelemetry } from "../lib/telemetry.js";
 
 try {
   const payload = await readStdinJson();
-  const cwd = payload.cwd || payload.working_directory;
-  logDebug("Stop", payload);
-  appendTelemetry({ telemetryPath: pluginRuntimeFile("telemetry.jsonl", cwd), event: "Stop", payload });
-  writeJson(handleStopPayload(payload, {
+  const cwd = resolveHookCwd(payload);
+  const normalized = { ...payload, cwd };
+  logDebug("Stop", normalized);
+  appendTelemetry({ telemetryPath: pluginRuntimeFile("telemetry.jsonl", cwd), event: "Stop", payload: normalized });
+  writeJson(handleStopPayload(normalized, {
     contextPath: pluginRuntimeFile("last-prompt-context.json", cwd),
     reportPath: pluginRuntimeFile("last-report.json", cwd),
     historyPath: pluginRuntimeFile("report-history.jsonl", cwd),

package/plugins/ctx/lib/analyzer.js

@@ -43,7 +43,10 @@ const SEMANTIC_ALIASES = {
   thong: ["notification", "notify", "message"],
   bao: ["notification", "notify", "message"],
   "thong-bao": ["notification", "notify", "message"],
-  thongbao: ["notification", "notify", "message"]
+  thongbao: ["notification", "notify", "message"],
+  authen: ["auth", "authentication", "login"],
+  authentication: ["auth", "authen", "login"],
+  recheck: ["check", "verify", "review"]
 };
 
 const MODERATION_TOKENS = new Set(["moderation", "moderate", "content-moderation", "approval", "approved", "reject", "rejected", "needs_review"]);
@@ -81,6 +84,11 @@ const TOOL_REFERENCE_TOKENS = new Set([
   "list_communities"
 ]);
 
+const ACTION_TOKENS = new Set([
+  "add", "avoid", "call", "check", "derive", "ensure", "filter", "follow", "prefer", "run",
+  "use", "validate", "verify", "write", "never", "always", "must", "should", "do"
+]);
+
 export function tokenize(value) {
   const normalized = String(value || "")
     .toLowerCase()
@@ -190,6 +198,7 @@ export function isDocumentationOnlyRule(rule) {
   if (/^<!--.*-->$/.test(normalized)) return true;
   if (DOCUMENTATION_HEADING_PATTERNS.some((pattern) => pattern.test(normalized))) return true;
   if (isMarkdownTableRule(normalized)) return true;
+  if (isGenericHeading(normalized)) return true;
   return false;
 }
 
@@ -209,6 +218,13 @@ function isMarkdownTableRule(content) {
   return /\btool\b/.test(lower) && /\buse\s+when\b/.test(lower) && toolReferenceCount >= 2;
 }
 
+function isGenericHeading(content) {
+  if (content.length > 80 || /[`.:;]/.test(content)) return false;
+  const tokens = tokenize(content);
+  if (tokens.length > 4) return false;
+  return !tokens.some((token) => ACTION_TOKENS.has(token));
+}
+
 function dedupeRules(rules) {
   const seen = new Set();
   return rules.filter((rule) => {

package/plugins/ctx/lib/antigravity-adapter.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import { resolveHookCwd } from "./hook-io.js";
+
+export function antigravityCwd(payload) {
+  return payload.cwd
+    || payload.working_directory
+    || payload.workspacePath
+    || payload.workspacePaths?.[0]
+    || resolveHookCwd(payload);
+}
+
+function textFromValue(value) {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map(textFromValue).filter(Boolean).join("\n");
+  if (typeof value !== "object") return "";
+  if (typeof value.text === "string") return value.text;
+  if (typeof value.content === "string") return value.content;
+  if (typeof value.message === "string") return value.message;
+  if (typeof value.userMessage === "string") return value.userMessage;
+  if (Array.isArray(value.parts)) return textFromValue(value.parts);
+  if (Array.isArray(value.content)) return textFromValue(value.content);
+  return "";
+}
+
+function looksUserAuthored(record) {
+  const role = String(record.role || record.author || record.type || record.sender || "").toLowerCase();
+  return !role || role.includes("user") || role.includes("human");
+}
+
+export function extractPromptFromAntigravityPayload(payload) {
+  const direct = payload.prompt || payload.userPrompt || payload.userMessage || payload.message;
+  if (direct) return textFromValue(direct);
+
+  const transcriptPath = payload.transcriptPath || payload.transcript_path;
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) return "";
+
+  try {
+    const lines = fs.readFileSync(transcriptPath, "utf8").trim().split(/\r?\n/).filter(Boolean).slice(-200);
+    for (const line of lines.reverse()) {
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (!looksUserAuthored(record)) continue;
+      const text = textFromValue(record.prompt || record.userPrompt || record.userMessage || record.message || record.content || record.parts);
+      if (text.trim()) return text.trim();
+    }
+  } catch {
+    return "";
+  }
+
+  return "";
+}

package/plugins/ctx/lib/antigravity-hooks.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+function commandFor(installRoot, scriptName, { injectPromptContext = true } = {}) {
+  const envPrefix = scriptName === "on-antigravity-preinvocation.js" && !injectPromptContext ? "CONTEXTOS_INJECT=0 " : "";
+  return `${envPrefix}node ${shellQuote(path.join(installRoot, "plugins", "ctx", "bin", scriptName))}`;
+}
+
+export function antigravityHooksPath() {
+  return process.env.ANTIGRAVITY_HOOKS_PATH
+    || path.join(process.env.HOME || process.cwd(), ".gemini", "config", "hooks.json");
+}
+
+export function buildAntigravityHooksConfig(existingConfig, { installRoot, injectPromptContext = true } = {}) {
+  const config = existingConfig && typeof existingConfig === "object" ? structuredClone(existingConfig) : {};
+  config.contextos = {
+    enabled: true,
+    PreInvocation: [
+      {
+        type: "command",
+        command: commandFor(installRoot, "on-antigravity-preinvocation.js", { injectPromptContext }),
+        timeout: 10
+      }
+    ],
+    Stop: [
+      {
+        type: "command",
+        command: commandFor(installRoot, "on-antigravity-stop.js"),
+        timeout: 10
+      }
+    ]
+  };
+  return config;
+}
+
+export function installAntigravityHooks({ hooksPath = antigravityHooksPath(), installRoot, injectPromptContext = true } = {}) {
+  const existing = readJsonFile(hooksPath, {});
+  const next = buildAntigravityHooksConfig(existing, { installRoot, injectPromptContext });
+  fs.mkdirSync(path.dirname(hooksPath), { recursive: true });
+  fs.writeFileSync(hooksPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return hooksPath;
+}

package/plugins/ctx/lib/antigravity-mcp.js

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+export function antigravityMcpConfigPaths() {
+  if (process.env.ANTIGRAVITY_MCP_CONFIG_PATH) {
+    return [process.env.ANTIGRAVITY_MCP_CONFIG_PATH];
+  }
+  const home = process.env.HOME || process.cwd();
+  return [
+    path.join(home, ".gemini", "antigravity", "mcp_config.json"),
+    path.join(home, ".gemini", "antigravity-cli", "mcp_config.json"),
+    path.join(home, ".gemini", "config", "mcp_config.json")
+  ];
+}
+
+export function buildAntigravityMcpConfig(existingConfig, { installRoot } = {}) {
+  const config = existingConfig && typeof existingConfig === "object" ? structuredClone(existingConfig) : {};
+  if (!config.mcpServers || typeof config.mcpServers !== "object") config.mcpServers = {};
+  config.mcpServers["ctx-mcp"] = {
+    command: "node",
+    args: [path.join(installRoot, "plugins", "ctx", "mcp", "server.js")]
+  };
+  return config;
+}
+
+export function installAntigravityMcp({ configPaths = antigravityMcpConfigPaths(), installRoot } = {}) {
+  const written = [];
+  for (const configPath of configPaths) {
+    const existing = readJsonFile(configPath, {});
+    const next = buildAntigravityMcpConfig(existing, { installRoot });
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    written.push(configPath);
+  }
+  return written;
+}

package/plugins/ctx/lib/benchmark.js

@@ -0,0 +1,72 @@
+import { parseRules, filterActionableRules, scoreRules } from "./analyzer.js";
+import { readAgentsChain } from "./reader.js";
+import { scheduleContext } from "./scheduler.js";
+
+export function benchmarkContext({ markdown, sources = [], task = "", openFiles = [], topK = 8 } = {}) {
+  const parsedRules = parseRules(markdown);
+  const actionableRules = filterActionableRules(parsedRules);
+  const scoredRules = scoreRules(actionableRules, task, openFiles);
+  const relevantRules = scoredRules.filter((rule) => Number(rule.score || 0) >= 0.1);
+  const scheduled = scheduleContext({ rules: scoredRules, relevantFiles: [] });
+
+  const originalPositions = new Map(actionableRules.map((rule, index) => [rule.content, index]));
+  const middleStart = Math.floor(actionableRules.length * 0.25);
+  const middleEnd = Math.ceil(actionableRules.length * 0.75);
+  const lostMiddle = relevantRules.filter((rule) => {
+    const index = originalPositions.get(rule.content);
+    return typeof index === "number" && index >= middleStart && index <= middleEnd;
+  });
+
+  return {
+    task,
+    sources,
+    rulesParsed: parsedRules.length,
+    actionableRules: actionableRules.length,
+    filteredRules: parsedRules.length - actionableRules.length,
+    relevantRules: relevantRules.length,
+    baseline: {
+      relevantRulesInMiddle: lostMiddle.length,
+      middleRiskPercent: relevantRules.length ? Math.round((lostMiddle.length / relevantRules.length) * 100) : 0
+    },
+    contextOS: {
+      highRules: scheduled.highRules.length,
+      midRules: scheduled.midRules.length,
+      topRules: scoredRules.slice(0, topK).map((rule) => ({
+        score: rule.score,
+        content: rule.content,
+        reasons: rule.reasons || []
+      })),
+      repeatsHighRulesAtEnd: scheduled.highRules.length > 0
+    }
+  };
+}
+
+export function benchmarkWorkspace({ cwd = process.cwd(), task = "", openFiles = [], topK = 8 } = {}) {
+  const merged = readAgentsChain({ cwd });
+  return benchmarkContext({
+    markdown: merged.content,
+    sources: merged.sources,
+    task,
+    openFiles,
+    topK
+  });
+}
+
+export function formatBenchmark(result) {
+  const lines = [];
+  lines.push("ContextOS benchmark");
+  lines.push(`Task: ${result.task || "(empty)"}`);
+  lines.push(`Rules: ${result.rulesParsed} parsed, ${result.actionableRules} actionable, ${result.filteredRules} filtered`);
+  lines.push(`Relevant rules: ${result.relevantRules}`);
+  lines.push(`Baseline middle-risk: ${result.baseline.relevantRulesInMiddle}/${result.relevantRules} relevant rules (${result.baseline.middleRiskPercent}%)`);
+  lines.push(`ContextOS scheduled: ${result.contextOS.highRules} high, ${result.contextOS.midRules} mid`);
+  lines.push(`Recency reminder: ${result.contextOS.repeatsHighRulesAtEnd ? "enabled" : "not needed"}`);
+  if (result.contextOS.topRules.length) {
+    lines.push("Top rules:");
+    for (const rule of result.contextOS.topRules) {
+      const reasons = rule.reasons?.length ? ` reasons:${rule.reasons.join(",")}` : "";
+      lines.push(`- ${Number(rule.score || 0).toFixed(2)} ${rule.content}${reasons}`);
+    }
+  }
+  return lines.join("\n");
+}

package/plugins/ctx/lib/claude-hooks.js

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { buildGlobalHooksConfig } from "./global-hooks.js";
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+export function claudeHome() {
+  return process.env.CLAUDE_HOME || path.join(process.env.HOME || process.cwd(), ".claude");
+}
+
+export function installClaudeHooks({ claudeHome: home = claudeHome(), installRoot, injectPromptContext = true } = {}) {
+  const settingsPath = path.join(home, "settings.json");
+  const existing = readJsonFile(settingsPath, {});
+  const next = buildGlobalHooksConfig(existing, {
+    marketplaceRoot: installRoot,
+    injectPromptContext
+  });
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return settingsPath;
+}

package/plugins/ctx/lib/claude-mcp.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return fallback;
+  return JSON.parse(raw);
+}
+
+export function claudeConfigPath() {
+  return process.env.CLAUDE_CONFIG_PATH || path.join(process.env.HOME || process.cwd(), ".claude.json");
+}
+
+export function buildClaudeMcpConfig(existingConfig, { installRoot } = {}) {
+  const config = existingConfig && typeof existingConfig === "object" ? structuredClone(existingConfig) : {};
+  if (!config.mcpServers || typeof config.mcpServers !== "object") config.mcpServers = {};
+  config.mcpServers["ctx-mcp"] = {
+    type: "stdio",
+    command: "node",
+    args: [path.join(installRoot, "plugins", "ctx", "mcp", "server.js")],
+    env: {}
+  };
+  return config;
+}
+
+export function installClaudeMcp({ configPath = claudeConfigPath(), installRoot } = {}) {
+  const existing = readJsonFile(configPath, {});
+  const next = buildClaudeMcpConfig(existing, { installRoot });
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return configPath;
+}

package/plugins/ctx/lib/embedding-scorer.js

@@ -57,6 +57,9 @@ export async function warmRuleEmbeddings({
   sources = [],
   allowRemote = true
 } = {}) {
+  if (!allowRemote && !isModelCacheReady(dataDir)) {
+    return { count: 0, cachePath: path.join(dataDir, "embeddings.db"), status: "missing-model" };
+  }
   const texts = [...new Set([
     task,
     ...rules.map((rule) => rule.content || "")
@@ -131,6 +134,16 @@ export function modelCacheDir(dataDir = defaultDataRoot()) {
   return path.join(dataDir, "models");
 }
 
+export function isModelCacheReady(dataDir = defaultDataRoot()) {
+  const modelDir = path.join(modelCacheDir(dataDir), ...DEFAULT_MODEL.split("/"));
+  return [
+    "config.json",
+    "tokenizer.json",
+    "tokenizer_config.json",
+    path.join("onnx", "model_quantized.onnx")
+  ].every((relativePath) => fs.existsSync(path.join(modelDir, relativePath)));
+}
+
 async function getCachedEmbedding({ cache, embedder, text, sources }) {
   const key = cacheKey(text, sources);
   const existing = cache.get(key);

package/plugins/ctx/lib/file-embedding-retriever.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { enhanceRuleScoresWithEmbeddings, warmRuleEmbeddings } from "./embedding-scorer.js";
+import { enhanceRuleScoresWithEmbeddings, isModelCacheReady, warmRuleEmbeddings } from "./embedding-scorer.js";
 
 const SOURCE_EXTENSIONS = new Set([
   ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".sql", ".md", ".json"
@@ -65,6 +65,7 @@ export async function warmFileEmbeddings({
   maxFiles = Number(process.env.CONTEXTOS_FILE_EMBEDDING_MAX_FILES || DEFAULT_MAX_FILES)
 } = {}) {
   if (!dataDir) return { count: 0, cachePath: null };
+  if (!allowRemote && !isModelCacheReady(dataDir)) return { count: 0, cachePath: null, status: "missing-model" };
   const files = listSourceFiles(cwd, { maxFiles });
   const rules = files.map((filePath) => ({ content: fileSearchText(filePath) }));
   return warmRuleEmbeddings({

package/plugins/ctx/lib/hook-io.js

@@ -15,6 +15,22 @@ export function writeJson(value) {
   process.stdout.write(`${JSON.stringify(value)}\n`);
 }
 
+export function resolveHookCwd(payload = {}) {
+  return payload.cwd
+    || payload.working_directory
+    || payload.workspacePath
+    || payload.workspace_path
+    || payload.workspaceRoot
+    || payload.workspace_root
+    || payload.projectDir
+    || payload.project_dir
+    || payload.workspacePaths?.[0]
+    || payload.workspace_paths?.[0]
+    || process.env.CLAUDE_PROJECT_DIR
+    || process.env.PWD
+    || process.cwd();
+}
+
 export function pluginDataDir(fileName = "", cwd = process.cwd()) {
   let root;
   try {

package/plugins/ctx/lib/measure.js

@@ -183,23 +183,31 @@ export function checkCompliance({ rules = [], addedLines = [], runtimeEvidence =
     if (!keywords.length || !addedLines.length) {
       results.push({
         rule,
-        status: "unknown",
+        status: isRuntimeOnly || !addedLines.length || !keywords.length ? "unmeasurable" : "unknown",
         kind: isRuntimeOnly ? "runtime" : kind,
         keywords,
         evidence: isRuntimeOnly
-          ? "requires runtime/tool-call telemetry; no matching runtime signal observed"
+          ? "requires runtime/tool-call telemetry; no runtime telemetry source observed"
           : (!addedLines.length ? "no added lines in git diff" : "no concrete compliance keywords found")
       });
       continue;
     }
 
     if (isRuntimeOnly) {
+      const hasRuntimeSource = Boolean(
+        runtimeEvidence.sources?.length ||
+        runtimeEvidence.signals?.length ||
+        runtimeEvidence.toolSignals?.length ||
+        runtimeEvidence.commandSignals?.length
+      );
       results.push({
         rule,
-        status: "unknown",
+        status: hasRuntimeSource ? "unknown" : "unmeasurable",
         kind: "runtime",
         keywords,
-        evidence: "requires runtime/tool-call telemetry; no matching runtime signal observed"
+        evidence: hasRuntimeSource
+          ? "requires runtime/tool-call telemetry; no matching runtime signal observed"
+          : "requires runtime/tool-call telemetry; no runtime telemetry source observed"
       });
       continue;
     }

package/plugins/ctx/lib/package-install.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+      fs.chmodSync(destPath, fs.statSync(srcPath).mode);
+    }
+  }
+}
+
+export function copyPath(src, dest) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    copyDir(src, dest);
+  } else {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(src, dest);
+    fs.chmodSync(dest, stat.mode);
+  }
+}
+
+export function copyPackageRoot({ rootDir, targetRoot }) {
+  fs.rmSync(targetRoot, { recursive: true, force: true });
+  for (const entry of [".agents", "bin", "plugins", "package.json", "package-lock.json", "README.md", "LICENSE", "node_modules"]) {
+    const src = path.join(rootDir, entry);
+    if (fs.existsSync(src)) copyPath(src, path.join(targetRoot, entry));
+  }
+  return targetRoot;
+}

package/plugins/ctx/lib/prompt-hook.js

@@ -1,6 +1,7 @@
 import { scheduleContext } from "./scheduler.js";
 import { appendJsonLine, writeJsonFile } from "./fs-utils.js";
 import { callCtxScoreContext } from "./ctx-mcp-client.js";
+import { resolveHookCwd } from "./hook-io.js";
 import path from "node:path";
 
 export async function handlePromptPayload(
@@ -16,7 +17,7 @@ export async function handlePromptPayload(
   } = {}
 ) {
   const prompt = payload.prompt || payload.message || payload.user_prompt || "";
-  const cwd = payload.cwd || payload.working_directory || process.cwd();
+  const cwd = resolveHookCwd(payload);
   const openFiles = payload.openFiles || payload.open_files || payload.files || [];
   const dataDir = dataPath ? path.dirname(dataPath) : undefined;
 

package/plugins/ctx/lib/reporter.js

@@ -5,6 +5,7 @@ export function buildReport({ cwd, prompt, relevantFiles, scheduled, gitSnapshot
   const followed = actionableCompliance.filter((item) => item.status === "followed");
   const ignored = actionableCompliance.filter((item) => item.status === "ignored");
   const unknown = actionableCompliance.filter((item) => item.status === "unknown");
+  const unmeasurable = actionableCompliance.filter((item) => item.status === "unmeasurable");
   const measured = followed.length + ignored.length;
   const efficiencyScore = measured ? Math.round((followed.length / measured) * 100) : null;
 
@@ -20,8 +21,10 @@ export function buildReport({ cwd, prompt, relevantFiles, scheduled, gitSnapshot
     followed,
     ignored,
     unknown,
+    unmeasurable,
     measuredRuleCount: measured,
     unknownRuleCount: unknown.length,
+    unmeasurableRuleCount: unmeasurable.length,
     efficiencyScore
   };
 }
@@ -32,7 +35,7 @@ export function formatReport(report) {
   lines.push("ContextOS report");
   lines.push(`Efficiency: ${report.efficiencyScore == null ? "unknown" : `${report.efficiencyScore}%`}`);
   lines.push(`Injected rules: ${report.injectedRuleCount || 0}`);
-  lines.push(`Rule outcomes: ${report.followed?.length || 0} followed, ${report.ignored?.length || 0} ignored, ${report.unknown?.length || 0} unknown`);
+  lines.push(`Rule outcomes: ${report.followed?.length || 0} followed, ${report.ignored?.length || 0} ignored, ${report.unknown?.length || 0} unknown, ${report.unmeasurable?.length || 0} unmeasurable`);
   lines.push(`Measured rules: ${report.measuredRuleCount ?? ((report.followed?.length || 0) + (report.ignored?.length || 0))}`);
   lines.push(`Changed files: ${report.changedFiles?.length ? report.changedFiles.join(", ") : "none detected"}`);
 
@@ -48,6 +51,7 @@ export function formatReport(report) {
   appendBucket(lines, "Followed", report.followed);
   appendBucket(lines, "Ignored", report.ignored);
   appendBucket(lines, "Unknown", report.unknown);
+  appendBucket(lines, "Unmeasurable", report.unmeasurable);
 
   if (report.ignored?.length) {
     lines.push(`Suggestion: fix ignored rule evidence first: ${truncate(report.ignored[0].rule?.content || "", 70)}`);
@@ -71,7 +75,8 @@ export function formatEvidence(report) {
   const items = [
     ...(report.followed || []).map((item) => ({ ...item, status: "followed" })),
     ...(report.ignored || []).map((item) => ({ ...item, status: "ignored" })),
-    ...(report.unknown || []).map((item) => ({ ...item, status: "unknown" }))
+    ...(report.unknown || []).map((item) => ({ ...item, status: "unknown" })),
+    ...(report.unmeasurable || []).map((item) => ({ ...item, status: "unmeasurable" }))
   ];
 
   if (!items.length) {
@@ -129,15 +134,18 @@ function sanitizeReport(report = {}) {
   const followed = (report.followed || []).filter((item) => !isSystemUserRule(item.rule));
   const ignored = (report.ignored || []).filter((item) => !isSystemUserRule(item.rule));
   const unknown = (report.unknown || []).filter((item) => !isSystemUserRule(item.rule));
+  const unmeasurable = (report.unmeasurable || []).filter((item) => !isSystemUserRule(item.rule));
   const measured = followed.length + ignored.length;
   return {
     ...report,
-    injectedRuleCount: followed.length + ignored.length + unknown.length,
+    injectedRuleCount: followed.length + ignored.length + unknown.length + unmeasurable.length,
     followed,
     ignored,
     unknown,
+    unmeasurable,
     measuredRuleCount: measured,
     unknownRuleCount: unknown.length,
+    unmeasurableRuleCount: unmeasurable.length,
     efficiencyScore: measured ? Math.round((followed.length / measured) * 100) : null
   };
 }