getprismo 0.1.41 → 0.1.42

package/lib/prismo-dev/agent.js

@@ -458,10 +458,20 @@ module.exports = function createAgent(deps) {
 
     let plannerResult = null;
     if (options.planRepairs && repairPlanner) {
+      // Fleet priors are anonymized cause x tier improve rates across all
+      // orgs; the planner uses them to pick a starting tier. Best-effort:
+      // planning works without them.
+      let fleetPriors = null;
+      try {
+        const endpoint = options.fleetPriorsEndpoint || `${apiBase(config)}/v1/dev/fleet/repair-priors`;
+        const response = await requestJson("GET", endpoint, config.token, null, options.timeoutMs || 8000);
+        fleetPriors = response.data && Array.isArray(response.data.priors) ? response.data.priors : null;
+      } catch (_) {}
       try {
         plannerResult = await repairPlanner.runPlannerOnce(rootDir, {
           execute: mode === "autopilot",
           sessionLimit: options.plannerSessionLimit,
+          fleetPriors,
         });
         const registered = plannerResult.executed
           ? await registerSelfRepair(config, plannerResult, options)

package/lib/prismo-dev/cli.js

@@ -3,9 +3,10 @@ const { printHelp, printCommandHelp } = require("./help");
 
 const VALID_COMMANDS = new Set([
   "dev", "init", "doctor", "firewall", "benchmark", "shield", "mcp",
-  "connect", "sync", "status", "disconnect", "agent", "connector", "setup", "scan",
+  "connect", "sync", "status", "disconnect", "agent", "connector", "setup", "scan", "digest",
   "optimize", "context", "cc", "cursor", "receipt", "instructions",
   "timeline", "replay", "boundaries", "usage", "guard", "watch", "demo", "repair",
+  "enforce", "hook",
 ]);
 
 function parseTokenBudget(value) {
@@ -59,10 +60,12 @@ function createCli(deps) {
     renderReceiptTerminal,
     buildReceipt,
     renderConnectTerminal,
+    renderDigestTerminal,
     renderDisconnectTerminal,
     renderStatusTerminal,
     renderSyncTerminal,
     runConnect,
+    runDigest,
     runDisconnect,
     runStatus,
     runSync,
@@ -73,6 +76,11 @@ function createCli(deps) {
     runRepair,
     renderPlannerTerminal,
     runPlannerOnce,
+    decidePreToolUse,
+    renderEnforceTerminal,
+    runEnforceInstall,
+    runEnforceStatus,
+    runEnforceUninstall,
     renderAgentTerminal,
     runAgent,
     renderConnectorTerminal,
@@ -464,6 +472,17 @@ function createCli(deps) {
       return;
     }
 
+    if (command === "digest") {
+      const json = rest.includes("--json");
+      const daysIndex = rest.indexOf("--days");
+      const result = await runDigest({
+        days: parsePositiveInt(daysIndex >= 0 ? rest[daysIndex + 1] : null, 7),
+      });
+      if (json) console.log(JSON.stringify(result, null, 2));
+      else console.log(renderDigestTerminal(result));
+      return;
+    }
+
     if (command === "status") {
       const json = rest.includes("--json");
       const result = runStatus();
@@ -801,6 +820,33 @@ function createCli(deps) {
       return;
     }
 
+    if (command === "hook") {
+      const subcommand = (rest[0] || "").toLowerCase();
+      if (subcommand !== "pretooluse") {
+        printCommandHelp("enforce");
+        return;
+      }
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      const decision = decidePreToolUse(process.cwd(), Buffer.concat(chunks).toString("utf8"));
+      if (decision) console.log(JSON.stringify(decision));
+      return;
+    }
+
+    if (command === "enforce") {
+      const json = rest.includes("--json");
+      const subcommand = (getPositionals(rest, new Set())[0] || "status").toLowerCase();
+      const target = getPositionals(rest, new Set())[1] || process.cwd();
+      const result = subcommand === "install"
+        ? runEnforceInstall(target)
+        : subcommand === "uninstall"
+          ? runEnforceUninstall(target)
+          : runEnforceStatus(target);
+      if (json) console.log(JSON.stringify(result, null, 2));
+      else console.log(renderEnforceTerminal(result));
+      return;
+    }
+
     if (command === "usage" || command === "watch") {
       const json = rest.includes("--json");
       const knownTools = new Set(["codex", "claude", "cursor", "all"]);

package/lib/prismo-dev/cloud-sync.js

@@ -371,6 +371,62 @@ module.exports = function createCloudSync(deps) {
     };
   }
 
+  async function runDigest(options = {}) {
+    const config = loadConfig();
+    if (!config || !config.token) {
+      return {
+        schemaVersion: 1,
+        command: "digest",
+        connected: false,
+        digest: null,
+        error: "not-connected",
+        next: [`${NPX_COMMAND} connect --token <token>`],
+      };
+    }
+    const base = String(config.apiUrl || DEFAULT_API_URL).replace(/\/$/, "");
+    const days = Math.max(1, Number(options.days || 7));
+    const endpoint = options.endpoint || `${base}/v1/dev/workspace/digest/agent?days=${encodeURIComponent(days)}`;
+    try {
+      const response = await requestJson("GET", endpoint, config.token, null, options.timeoutMs || 10000);
+      return {
+        schemaVersion: 1,
+        command: "digest",
+        connected: true,
+        apiUrl: base,
+        digest: response.data,
+      };
+    } catch (error) {
+      return {
+        schemaVersion: 1,
+        command: "digest",
+        connected: true,
+        apiUrl: base,
+        digest: null,
+        error: error && error.message ? error.message : String(error),
+      };
+    }
+  }
+
+  function renderDigestTerminal(result) {
+    const lines = [];
+    lines.push("");
+    lines.push("PrismoDev Digest");
+    lines.push("");
+    if (!result.connected) {
+      lines.push("Status: not connected");
+      lines.push("");
+      lines.push("Next");
+      (result.next || []).forEach((item, index) => lines.push(`${index + 1}. ${item}`));
+      return lines.join("\n");
+    }
+    if (!result.digest) {
+      lines.push(`Could not load digest${result.error ? `: ${result.error}` : "."}`);
+      return lines.join("\n");
+    }
+    (result.digest.lines || [result.digest.headline]).forEach((line) => lines.push(line));
+    return lines.join("\n");
+  }
+
   function runStatus() {
     const config = loadConfig();
     const state = readJson(statePath());
@@ -499,10 +555,12 @@ module.exports = function createCloudSync(deps) {
     estimateWaste,
     loadConfig,
     renderConnectTerminal,
+    renderDigestTerminal,
     renderDisconnectTerminal,
     renderStatusTerminal,
     renderSyncTerminal,
     runConnect,
+    runDigest,
     runDisconnect,
     runStatus,
     runSync,

package/lib/prismo-dev/enforce.js

@@ -0,0 +1,287 @@
+module.exports = function createEnforce(deps) {
+  const {
+    fs,
+    path,
+    NPX_COMMAND,
+    runFirewall,
+  } = deps;
+
+  const HOOK_COMMAND = `${NPX_COMMAND} hook pretooluse`;
+  const FILE_TOOLS = new Set(["Read", "Glob", "Grep", "NotebookRead"]);
+  const MAX_IDENTICAL_COMMANDS = 3;
+  const MAX_TRACKED_SESSIONS = 8;
+
+  function blockedContextPath(root) {
+    return path.join(root, ".prismo", "blocked-context.txt");
+  }
+
+  function enforceStatePath(root) {
+    return path.join(root, ".prismo", "enforce-state.json");
+  }
+
+  function settingsPath(root) {
+    return path.join(root, ".claude", "settings.json");
+  }
+
+  function readBlockedPatterns(root) {
+    try {
+      return fs.readFileSync(blockedContextPath(root), "utf8")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith("#"));
+    } catch {
+      return [];
+    }
+  }
+
+  function readState(root) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(enforceStatePath(root), "utf8"));
+      return parsed && typeof parsed === "object" ? { sessions: {}, ...parsed } : { sessions: {} };
+    } catch {
+      return { sessions: {} };
+    }
+  }
+
+  function writeState(root, state) {
+    const filePath = enforceStatePath(root);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  }
+
+  function relativePath(root, filePath) {
+    const value = String(filePath || "");
+    const resolvedRoot = path.resolve(root);
+    if (value.startsWith(`${resolvedRoot}${path.sep}`)) return value.slice(resolvedRoot.length + 1);
+    if (value === resolvedRoot) return ".";
+    return value.replace(/^\.\//, "");
+  }
+
+  function matchesBlocked(relPath, pattern) {
+    const candidate = String(relPath || "").replace(/\\/g, "/");
+    const rule = String(pattern || "").trim();
+    if (!candidate || !rule) return false;
+    if (rule.endsWith("/**")) {
+      const dir = rule.slice(0, -3).replace(/\/$/, "");
+      return candidate === dir || candidate.startsWith(`${dir}/`) || candidate.includes(`/${dir}/`);
+    }
+    if (rule.startsWith("*.")) {
+      return candidate.endsWith(rule.slice(1));
+    }
+    return candidate === rule
+      || candidate.endsWith(`/${rule}`)
+      || candidate.includes(`/${rule}/`)
+      || candidate.startsWith(`${rule}/`);
+  }
+
+  function deny(reason) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: reason,
+      },
+    };
+  }
+
+  // Decide whether a PreToolUse event should be blocked. Returns the hook
+  // response object for a deny, or null to allow. Fails open: any parse or
+  // state error allows the call rather than breaking the user's agent.
+  function decidePreToolUse(rootDir, rawEvent) {
+    let event;
+    try {
+      event = typeof rawEvent === "string" ? JSON.parse(rawEvent) : rawEvent;
+    } catch {
+      return null;
+    }
+    if (!event || typeof event !== "object") return null;
+    const root = path.resolve(event.cwd || rootDir || process.cwd());
+    const toolName = String(event.tool_name || "");
+    const toolInput = event.tool_input && typeof event.tool_input === "object" ? event.tool_input : {};
+
+    try {
+      if (FILE_TOOLS.has(toolName)) {
+        const target = toolInput.file_path || toolInput.notebook_path || toolInput.path || null;
+        if (!target) return null;
+        const relPath = relativePath(root, target);
+        const patterns = readBlockedPatterns(root);
+        const hit = patterns.find((pattern) => matchesBlocked(relPath, pattern));
+        if (hit) {
+          return deny(
+            `Prismo context firewall: "${relPath}" is blocked context (rule: ${hit}). `
+            + "It is generated output that wastes agent tokens. Use the .prismo/ context packs instead, "
+            + `or run \`${NPX_COMMAND} shield -- <command>\` if you need its contents summarized.`
+          );
+        }
+        return null;
+      }
+
+      if (toolName === "Bash") {
+        const command = String(toolInput.command || "").trim().replace(/\s+/g, " ");
+        if (!command) return null;
+        const sessionId = String(event.session_id || "unknown");
+        const state = readState(root);
+        const sessions = state.sessions || {};
+        const session = sessions[sessionId] || { commands: {}, updatedAt: null };
+        const count = Number(session.commands[command] || 0);
+        if (count >= MAX_IDENTICAL_COMMANDS) {
+          return deny(
+            `Prismo loop breaker: this exact command has already run ${count} times in this session. `
+            + "Repeating it again will not change the outcome and floods context. Change the approach, "
+            + `or capture its output once with \`${NPX_COMMAND} shield -- ${command}\`.`
+          );
+        }
+        session.commands[command] = count + 1;
+        session.updatedAt = new Date().toISOString();
+        sessions[sessionId] = session;
+        const ids = Object.keys(sessions)
+          .sort((a, b) => String(sessions[b].updatedAt || "").localeCompare(String(sessions[a].updatedAt || "")));
+        state.sessions = Object.fromEntries(ids.slice(0, MAX_TRACKED_SESSIONS).map((id) => [id, sessions[id]]));
+        writeState(root, state);
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  function readSettings(root) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(settingsPath(root), "utf8"));
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+
+  function isPrismoHookEntry(entry) {
+    try {
+      return JSON.stringify(entry).includes("hook pretooluse");
+    } catch {
+      return false;
+    }
+  }
+
+  function hookInstalled(root) {
+    const settings = readSettings(root);
+    const entries = settings.hooks && Array.isArray(settings.hooks.PreToolUse) ? settings.hooks.PreToolUse : [];
+    return entries.some(isPrismoHookEntry);
+  }
+
+  function runEnforceInstall(rootDir = process.cwd(), options = {}) {
+    const root = path.resolve(rootDir);
+    const actions = [];
+
+    if (!fs.existsSync(blockedContextPath(root)) && runFirewall && !options.noFirewall) {
+      runFirewall(root, { task: "enforcement", dryRun: false });
+      actions.push("Generated .prismo context firewall policy (allowed/blocked context)");
+    }
+
+    const filePath = settingsPath(root);
+    const settings = readSettings(root);
+    settings.hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+    const entries = Array.isArray(settings.hooks.PreToolUse) ? settings.hooks.PreToolUse : [];
+    if (entries.some(isPrismoHookEntry)) {
+      actions.push("Prismo PreToolUse hook already installed in .claude/settings.json");
+    } else {
+      const existed = fs.existsSync(filePath);
+      if (existed) {
+        fs.copyFileSync(filePath, `${filePath}.prismo-backup`);
+        actions.push("Backed up .claude/settings.json to settings.json.prismo-backup");
+      }
+      entries.push({
+        matcher: "Read|Glob|Grep|NotebookRead|Bash",
+        hooks: [{ type: "command", command: HOOK_COMMAND }],
+      });
+      settings.hooks.PreToolUse = entries;
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+      actions.push(`${existed ? "Updated" : "Created"} .claude/settings.json with the Prismo PreToolUse hook`);
+    }
+
+    return {
+      schemaVersion: 1,
+      command: "enforce",
+      mode: "install",
+      installed: true,
+      blockedRules: readBlockedPatterns(root).length,
+      actions,
+      generatedAt: new Date().toISOString(),
+    };
+  }
+
+  function runEnforceUninstall(rootDir = process.cwd()) {
+    const root = path.resolve(rootDir);
+    const filePath = settingsPath(root);
+    const settings = readSettings(root);
+    const actions = [];
+    const entries = settings.hooks && Array.isArray(settings.hooks.PreToolUse) ? settings.hooks.PreToolUse : [];
+    const kept = entries.filter((entry) => !isPrismoHookEntry(entry));
+    if (kept.length !== entries.length) {
+      if (kept.length) settings.hooks.PreToolUse = kept;
+      else if (settings.hooks) delete settings.hooks.PreToolUse;
+      fs.writeFileSync(filePath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+      actions.push("Removed the Prismo PreToolUse hook from .claude/settings.json");
+    } else {
+      actions.push("No Prismo PreToolUse hook found in .claude/settings.json");
+    }
+    return {
+      schemaVersion: 1,
+      command: "enforce",
+      mode: "uninstall",
+      installed: false,
+      actions,
+      generatedAt: new Date().toISOString(),
+    };
+  }
+
+  function runEnforceStatus(rootDir = process.cwd()) {
+    const root = path.resolve(rootDir);
+    const state = readState(root);
+    return {
+      schemaVersion: 1,
+      command: "enforce",
+      mode: "status",
+      installed: hookInstalled(root),
+      blockedRules: readBlockedPatterns(root).length,
+      trackedSessions: Object.keys(state.sessions || {}).length,
+      settingsPath: path.join(".claude", "settings.json"),
+      generatedAt: new Date().toISOString(),
+    };
+  }
+
+  function renderEnforceTerminal(result) {
+    const lines = [];
+    lines.push("");
+    lines.push("PrismoDev Enforce");
+    lines.push("");
+    if (result.mode === "status") {
+      lines.push(`Hook installed: ${result.installed ? "yes" : "no"}`);
+      lines.push(`Blocked-context rules: ${result.blockedRules}`);
+      lines.push(`Sessions tracked for loop breaking: ${result.trackedSessions}`);
+      if (!result.installed) {
+        lines.push("");
+        lines.push(`Run \`${NPX_COMMAND} enforce install\` to enforce the context firewall at runtime.`);
+      }
+      return lines.join("\n");
+    }
+    (result.actions || []).forEach((action) => lines.push(`- ${action}`));
+    if (result.mode === "install") {
+      lines.push("");
+      lines.push(`Blocked-context rules enforced: ${result.blockedRules}`);
+      lines.push("Claude Code will now be denied reads of blocked context and fourth retries of an identical command.");
+      lines.push("Other agents still follow the .prismo policy files advisorily.");
+    }
+    return lines.join("\n");
+  }
+
+  return {
+    decidePreToolUse,
+    matchesBlocked,
+    renderEnforceTerminal,
+    runEnforceInstall,
+    runEnforceStatus,
+    runEnforceUninstall,
+  };
+};

package/lib/prismo-dev/help.js

@@ -16,6 +16,7 @@ Usage:
   prismo connector [status|install|start|stop|uninstall] [--json] [--interval N] [--sync-interval N] [--mode observe|suggest|autopilot] [path]
   prismo sync [--json] [--dry-run] [--watch] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
   prismo status [--json]
+  prismo digest [--json] [--days N]
   prismo disconnect [--json]
   prismo agent [--json] [--once] [--watch] [--interval N] [--sync-interval N] [--limit N] [--mode MODE] [path]
   prismo setup [--json] [--proxy-url URL] [path]
@@ -34,6 +35,7 @@ Usage:
   prismo usage [codex|claude|cursor|all] [--json] [--limit N] [path]
   prismo guard [codex|claude|cursor|all] [--json] [--watch] [--once] [--no-sync] [--dry-run] [--limit N] [--budget N] [--interval N] [path]
   prismo repair <cause|auto> [--json] [--dry-run] [--tier mild|aggressive] [--limit N] [--budget N] [--scope SCOPE] [path] [-- <command ...>]
+  prismo enforce [status|install|uninstall] [--json] [path]
   prismo watch [codex|claude|cursor|all] [--json] [--once] [--agents] [--report] [--rescue] [--guardrails] [--throttle] [--events] [--no-events] [--auto] [--budget N] [--redact-paths] [--interval N] [path]
   prismo demo
 
@@ -49,6 +51,7 @@ Commands:
   connector   Install or manage the background Prismo Workspace connector.
   sync        Send safe aggregate local agent telemetry to Prismo; use --watch for background-style sync.
   status      Show local PrismoDev connection and last sync state.
+  digest      Print the verified-savings summary for the last N days, ready to paste into Slack.
   disconnect  Remove the local PrismoDev cloud connection.
   agent       Claim and execute safe workspace actions queued from Prismo Cloud.
   scan        Run PrismoDev for Claude Code, Codex, Cursor, and AI coding workflows.
@@ -64,6 +67,7 @@ Commands:
   usage       Read local Codex/Claude Code/Cursor session logs and summarize token usage.
   guard       Run proactive local guardrails and sync prevention events to Prismo.
   repair      Run the cause-specific repair for a detected waste cause; "auto" lets the planner pick.
+  enforce     Enforce the context firewall at runtime via Claude Code hooks (block blocked-context reads and command loops).
   watch       Refresh local session usage in the terminal.
   demo        Show sample output without needing a messy repo.
   setup       Detect coding tools, tracking modes, local logs, and Prismo proxy readiness.
@@ -321,6 +325,28 @@ Output:
   --dry-run with auto prints the planner decision without executing.
   --tier aggressive forces the stronger repair; cloud-queued actions carry it automatically after a no-change/regressed verdict.
   Repairs only write .prismo/ files and append ignore rules with backups; they never overwrite CLAUDE.md, AGENTS.md, .gitignore, or source code.`,
+  enforce: `PrismoDev Enforce
+
+Usage:
+  prismo enforce [status|install|uninstall] [--json] [path]
+
+Examples:
+  prismo enforce status
+  prismo enforce install
+  prismo enforce uninstall
+
+What install does:
+  1. Generates the .prismo context firewall policy if it does not exist yet.
+  2. Adds a PreToolUse hook to .claude/settings.json (with a backup) that runs "prismo hook pretooluse".
+
+What the hook enforces (Claude Code only):
+  - Denies Read/Glob/Grep/NotebookRead calls into blocked context (.prismo/blocked-context.txt) with a reason pointing at the context packs.
+  - Denies the 4th attempt of an identical Bash command in one session and suggests prismo shield instead.
+
+Notes:
+  Enforcement fails open: malformed events or missing policy files allow the call.
+  Other coding agents still follow the .prismo policy files advisorily.
+  Uninstall removes only the Prismo hook entry and leaves the rest of settings.json untouched.`,
   watch: `Prismo Watch
 
 Usage:

package/lib/prismo-dev/repair-planner.js

@@ -20,6 +20,11 @@ module.exports = function createRepairPlanner(deps) {
     baselineDays: 14,
     rateEpsilon: 0.01,
     historyLimit: 20,
+    // Fleet priors: minimum cross-org sample before trusting a rate, and the
+    // rates at which a first repair starts aggressive instead of mild.
+    fleetMinSample: 5,
+    fleetMildMaxRate: 0.4,
+    fleetAggressiveMinRate: 0.5,
   };
 
   function nowIso() {
@@ -127,6 +132,21 @@ module.exports = function createRepairPlanner(deps) {
     return verdict;
   }
 
+  // When the fleet has enough verified outcomes showing mild repairs rarely
+  // fix a cause while aggressive ones usually do, start aggressive on the
+  // first local repair instead of re-learning what the fleet already knows.
+  function fleetStartingTier(cause, priors, config) {
+    if (!Array.isArray(priors)) return null;
+    const mild = priors.find((p) => p && p.cause === cause && p.tier === "mild");
+    const aggressive = priors.find((p) => p && p.cause === cause && p.tier === "aggressive");
+    if (!mild || !aggressive) return null;
+    if (Number(mild.attempts || 0) < config.fleetMinSample || Number(aggressive.attempts || 0) < config.fleetMinSample) return null;
+    if (Number(mild.improveRate || 0) <= config.fleetMildMaxRate && Number(aggressive.improveRate || 0) >= config.fleetAggressiveMinRate) {
+      return { mild, aggressive };
+    }
+    return null;
+  }
+
   // Decide what (if anything) to repair next. Pure read: does not execute
   // or modify state, so observe/suggest modes can call it safely.
   function plan(root, options = {}) {
@@ -150,6 +170,11 @@ module.exports = function createRepairPlanner(deps) {
       const entry = state.causes[scored.cause] || null;
       let verdict = null;
       let tier = "mild";
+      let fleet = null;
+      if (!entry || !entry.lastRepairAt) {
+        fleet = fleetStartingTier(scored.cause, options.fleetPriors, config);
+        if (fleet) tier = "aggressive";
+      }
       if (entry && entry.lastRepairAt) {
         const repairedAtMs = Date.parse(entry.lastRepairAt);
         if (Number.isFinite(repairedAtMs)) {
@@ -182,7 +207,9 @@ module.exports = function createRepairPlanner(deps) {
           previousVerdict: verdict ? verdict.status : null,
           reason: verdict && tier === "aggressive"
             ? `Last ${entry.lastTier} repair came back ${verdict.status}; escalating to aggressive.`
-            : `${scored.cause} is the top waste cause (${scored.wastedTokens.toLocaleString()} tokens, ${(scored.wasteRate * 100).toFixed(1)}% of observed).`,
+            : fleet
+              ? `Fleet experience: mild repairs improved this cause ${(Number(fleet.mild.improveRate) * 100).toFixed(0)}% of the time vs ${(Number(fleet.aggressive.improveRate) * 100).toFixed(0)}% aggressive — starting aggressive.`
+              : `${scored.cause} is the top waste cause (${scored.wastedTokens.toLocaleString()} tokens, ${(scored.wasteRate * 100).toFixed(1)}% of observed).`,
         };
       } else {
         skipped.push({ cause: scored.cause, reason: "lower-priority" });

package/lib/prismo-dev-scan.js

@@ -275,10 +275,12 @@ const {
   estimateWaste,
   loadConfig,
   renderConnectTerminal,
+  renderDigestTerminal,
   renderDisconnectTerminal,
   renderStatusTerminal,
   renderSyncTerminal,
   runConnect,
+  runDigest,
   runDisconnect,
   runStatus,
   runSync,
@@ -332,6 +334,19 @@ const {
   runRepair,
 } = repairExecutors;
 
+const {
+  decidePreToolUse,
+  renderEnforceTerminal,
+  runEnforceInstall,
+  runEnforceStatus,
+  runEnforceUninstall,
+} = require("./prismo-dev/enforce")({
+  fs,
+  path,
+  NPX_COMMAND,
+  runFirewall,
+});
+
 const repairPlanner = require("./prismo-dev/repair-planner")({
   fs,
   path,
@@ -477,10 +492,12 @@ const { runCli } = require("./prismo-dev/cli")({
   renderReceiptTerminal,
   buildReceipt,
   renderConnectTerminal,
+  renderDigestTerminal,
   renderDisconnectTerminal,
   renderStatusTerminal,
   renderSyncTerminal,
   runConnect,
+  runDigest,
   runDisconnect,
   runStatus,
   runSync,
@@ -491,6 +508,11 @@ const { runCli } = require("./prismo-dev/cli")({
   runRepair,
   renderPlannerTerminal,
   runPlannerOnce,
+  decidePreToolUse,
+  renderEnforceTerminal,
+  runEnforceInstall,
+  runEnforceStatus,
+  runEnforceUninstall,
   renderAgentTerminal,
   runAgent,
   renderConnectorTerminal,
@@ -596,6 +618,11 @@ module.exports = {
   REPAIR_CAUSES,
   runPlannerOnce,
   renderPlannerTerminal,
+  decidePreToolUse,
+  renderEnforceTerminal,
+  runEnforceInstall,
+  runEnforceStatus,
+  runEnforceUninstall,
   runConnectorInstall,
   runConnectorStart,
   runConnectorStatus,

package/package.json

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