getprismo 0.1.54 → 0.1.56

package/lib/prismo-dev/agent.js

@@ -905,9 +905,9 @@ module.exports = function createAgent(deps) {
   async function runAgent(rootDir = process.cwd(), options = {}) {
     if (!options.watch) return runAgentOnce(rootDir, options);
 
-    const intervalMs = Math.max(5, Number(options.interval || 15)) * 1000;
-    const syncIntervalMs = Math.max(30, Number(options.syncInterval || 60)) * 1000;
-    const detectIntervalMs = Math.max(60, Number(options.detectInterval || 300)) * 1000;
+    const intervalMs = Math.max(15, Number(options.interval || 60)) * 1000;
+    const syncIntervalMs = Math.max(60, Number(options.syncInterval || 300)) * 1000;
+    const detectIntervalMs = Math.max(300, Number(options.detectInterval || 900)) * 1000;
     const plannerIntervalMs = Math.max(60, Number(options.plannerInterval || 600)) * 1000;
     let running = true;
     let sleepResolve = null;

package/lib/prismo-dev/cli.js

@@ -3,7 +3,7 @@ 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", "digest",
+  "connect", "sync", "status", "disconnect", "agent", "connector", "setup", "scan", "digest", "sessions", "report",
   "optimize", "context", "cc", "cursor", "receipt", "instructions",
   "timeline", "replay", "boundaries", "usage", "guard", "watch", "demo", "repair",
   "enforce", "bridge", "hook", "protect",
@@ -69,6 +69,10 @@ function createCli(deps) {
     runDisconnect,
     runStatus,
     runSync,
+    buildSessionsView,
+    renderSessionsTerminal,
+    buildLocalReport,
+    renderLocalReportTerminal,
     renderGuardTerminal,
     runGuard,
     REPAIR_CAUSES,
@@ -353,8 +357,8 @@ function createCli(deps) {
       });
       if (result.connected && !rest.includes("--no-agent") && runConnectorInstall) {
         result.connector = runConnectorInstall(target, {
-          interval: parsePositiveInt(intervalIndex >= 0 ? rest[intervalIndex + 1] : null, 15),
-          syncInterval: parsePositiveInt(syncIntervalIndex >= 0 ? rest[syncIntervalIndex + 1] : null, 60),
+          interval: parsePositiveInt(intervalIndex >= 0 ? rest[intervalIndex + 1] : null, 60),
+          syncInterval: parsePositiveInt(syncIntervalIndex >= 0 ? rest[syncIntervalIndex + 1] : null, 300),
           mode: modeValue,
           dryRun: rest.includes("--dry-run"),
         });
@@ -385,8 +389,8 @@ function createCli(deps) {
       let result;
       if (action === "install") {
         result = runConnectorInstall(target, {
-          interval: parsePositiveInt(intervalIndex >= 0 ? rest[intervalIndex + 1] : null, 15),
-          syncInterval: parsePositiveInt(syncIntervalIndex >= 0 ? rest[syncIntervalIndex + 1] : null, 60),
+          interval: parsePositiveInt(intervalIndex >= 0 ? rest[intervalIndex + 1] : null, 60),
+          syncInterval: parsePositiveInt(syncIntervalIndex >= 0 ? rest[syncIntervalIndex + 1] : null, 300),
           mode: modeValue,
           dryRun: rest.includes("--dry-run"),
         });
@@ -458,9 +462,9 @@ function createCli(deps) {
         autoDetect: !rest.includes("--no-detect"),
         planRepairs: !rest.includes("--no-planner"),
         noSync: rest.includes("--no-sync"),
-        interval: parsePositiveInt(intervalIndex >= 0 ? rest[intervalIndex + 1] : null, 15),
-        syncInterval: parsePositiveInt(syncIntervalIndex >= 0 ? rest[syncIntervalIndex + 1] : null, 60),
-        detectInterval: parsePositiveInt(detectIntervalIndex >= 0 ? rest[detectIntervalIndex + 1] : null, 300),
+        interval: parsePositiveInt(intervalIndex >= 0 ? rest[intervalIndex + 1] : null, 60),
+        syncInterval: parsePositiveInt(syncIntervalIndex >= 0 ? rest[syncIntervalIndex + 1] : null, 300),
+        detectInterval: parsePositiveInt(detectIntervalIndex >= 0 ? rest[detectIntervalIndex + 1] : null, 900),
         plannerInterval: parsePositiveInt(plannerIntervalIndex >= 0 ? rest[plannerIntervalIndex + 1] : null, 600),
         limit: parsePositiveInt(limitIndex >= 0 ? rest[limitIndex + 1] : null, 5),
         syncLimit: parsePositiveInt(limitIndex >= 0 ? rest[limitIndex + 1] : null, 20),
@@ -474,6 +478,34 @@ function createCli(deps) {
       return;
     }
 
+    if (command === "sessions") {
+      const json = rest.includes("--json");
+      const limitIndex = rest.indexOf("--limit");
+      const toolIndex = rest.indexOf("--tool");
+      const target = getPositionals(rest, new Set(["--limit", "--tool"]))[0] || process.cwd();
+      const view = buildSessionsView(target, {
+        limit: parsePositiveInt(limitIndex >= 0 ? rest[limitIndex + 1] : null, 10),
+        tool: toolIndex >= 0 ? rest[toolIndex + 1] : "all",
+        allRepos: rest.includes("--all-repos"),
+      });
+      if (json) console.log(JSON.stringify(view, null, 2));
+      else console.log(renderSessionsTerminal(view));
+      return;
+    }
+
+    if (command === "report") {
+      const json = rest.includes("--json");
+      const limitIndex = rest.indexOf("--limit");
+      const target = getPositionals(rest, new Set(["--limit"]))[0] || process.cwd();
+      const report = buildLocalReport(target, {
+        limit: parsePositiveInt(limitIndex >= 0 ? rest[limitIndex + 1] : null, 10),
+        allRepos: rest.includes("--all-repos"),
+      });
+      if (json) console.log(JSON.stringify(report, null, 2));
+      else console.log(renderLocalReportTerminal(report));
+      return;
+    }
+
     if (command === "digest") {
       const json = rest.includes("--json");
       const daysIndex = rest.indexOf("--days");

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

@@ -378,6 +378,13 @@ module.exports = function createCloudSync(deps) {
     };
   }
 
+  function sessionsFingerprint(sessions) {
+    const parts = (sessions || [])
+      .map((s) => `${s.sessionId || ""}:${s.updatedAt || ""}:${s.tokens?.display || 0}:${s.waste?.wastedTokens || 0}`)
+      .sort();
+    return `${parts.length}|${parts.join("|")}`;
+  }
+
   async function runSync(rootDir = process.cwd(), options = {}) {
     const config = loadConfig();
     const payload = buildSyncPayload(rootDir, {
@@ -408,16 +415,29 @@ module.exports = function createCloudSync(deps) {
       };
     }
     const endpoint = options.endpoint || `${String(config.apiUrl || DEFAULT_API_URL).replace(/\/$/, "")}/v1/dev/sessions/sync`;
+
+    // Skip the upload when nothing changed since the last sync. The connector
+    // re-runs on a short interval, but session data only changes when the user
+    // is actually coding, so most syncs are no-ops; sending them anyway is the
+    // main driver of needless backend load and network egress.
+    const fingerprint = sessionsFingerprint(payload.sessions);
+    if (!options.force) {
+      const previous = readJson(statePath());
+      if (previous && previous.fingerprint === fingerprint) {
+        return { schemaVersion: 1, command: "sync", synced: true, skipped: true, reason: "unchanged", statePath: statePath(), aggregate: payload.aggregate };
+      }
+    }
+
     const response = await requestJson("POST", endpoint, config.token, payload, options.timeoutMs || 8000);
-    const state = {
+    writeJson(statePath(), {
       schemaVersion: 1,
       lastSyncAt: new Date().toISOString(),
       endpoint,
+      fingerprint,
       repo: payload.repo,
       aggregate: payload.aggregate,
       response: response.data,
-    };
-    writeJson(statePath(), state);
+    });
     return {
       schemaVersion: 1,
       command: "sync",

package/lib/prismo-dev/connector.js

@@ -78,9 +78,12 @@ module.exports = function createConnector(deps) {
 
   function writeRunner(rootDir, options = {}) {
     const root = path.resolve(rootDir || process.cwd());
-    const interval = Math.max(5, Number(options.interval || 15));
-    const syncInterval = Math.max(30, Number(options.syncInterval || 60));
-    const detectInterval = Math.max(60, Number(options.detectInterval || 300));
+    // Background poll cadence. Kept conservative so an always-on connector
+    // stays light on API/database traffic; agent sessions change on the order
+    // of minutes, not seconds, so fast polling only adds idle load.
+    const interval = Math.max(15, Number(options.interval || 60));
+    const syncInterval = Math.max(60, Number(options.syncInterval || 300));
+    const detectInterval = Math.max(300, Number(options.detectInterval || 900));
     const mode = options.mode || "autopilot";
     fs.mkdirSync(connectorDir(), { recursive: true });
     const command = `${BACKGROUND_COMMAND} agent --watch --interval ${interval} --sync-interval ${syncInterval} --detect-interval ${detectInterval} --mode ${shellEscape(mode)} ${shellEscape(root)}`;

package/lib/prismo-dev/help.js

@@ -17,6 +17,8 @@ Usage:
   prismo bridge [--json] [path]
   prismo sync [--json] [--dry-run] [--watch] [--all-repos] [--interval N] [--limit N] [--tool all|codex|claude|cursor] [path]
   prismo status [--json]
+  prismo sessions [--json] [--all-repos] [--limit N] [--tool all|codex|claude|cursor] [path]
+  prismo report [--json] [--all-repos] [--limit N] [path]
   prismo digest [--json] [--days N]
   prismo disconnect [--json]
   prismo agent [--json] [--once] [--watch] [--interval N] [--sync-interval N] [--limit N] [--mode MODE] [path]
@@ -54,6 +56,8 @@ Commands:
   bridge     Explain optional agent bridge mode and live interception levels.
   sync        Send safe aggregate local agent telemetry to Prismo; use --watch for background-style sync.
   status      Show local PrismoDev connection and last sync state.
+  sessions    List recent local agent sessions with tokens, waste, risk, and top cause (add --all-repos for every repo).
+  report      Local waste snapshot: observed/wasted tokens, top causes, repeated reads/commands, and the next action. No connection needed.
   digest      Print the launch report: verified saved tokens/dollars first, with live prevention labeled estimated.
   disconnect  Remove the local PrismoDev cloud connection.
   agent       Claim and execute safe workspace actions queued from Prismo Cloud.

package/lib/prismo-dev/sessions-report.js

@@ -0,0 +1,196 @@
+module.exports = function createSessionsReport(deps) {
+  const {
+    path,
+    getUsageSummary,
+    estimateWaste,
+    formatTokenCount,
+  } = deps;
+
+  const CAUSE_LABELS = {
+    "tool-output-flood": "Tool-output floods",
+    "repeated-file-reads": "Repeated file reads",
+    "generated-artifacts": "Generated artifacts",
+    "context-loop": "Context loops",
+    "long-session-buildup": "Long-session buildup",
+    "low-signal": "No strong waste signal",
+  };
+
+  const NEXT_ACTION = {
+    "tool-output-flood": "Run noisy commands through `prismo shield -- <command>` so output stays out of context.",
+    "repeated-file-reads": "Run `prismo repair repeated-file-reads`, then start sessions from .prismo context packs.",
+    "generated-artifacts": "Run `prismo repair generated-artifacts` to ignore build output and artifacts.",
+    "context-loop": "Run `prismo repair context-loop` and stop retrying failing commands.",
+    "long-session-buildup": "Split work at task boundaries; start fresh sessions from `prismo context`.",
+    "low-signal": "Nothing urgent. Run `prismo doctor` for a baseline.",
+  };
+
+  function repoBasename(session, fallbackRoot) {
+    const cwd = session && session.cwd ? session.cwd : fallbackRoot;
+    try {
+      return path.basename(path.resolve(cwd || process.cwd()));
+    } catch {
+      return "unknown";
+    }
+  }
+
+  function collect(rootDir, options = {}) {
+    const root = path.resolve(rootDir || process.cwd());
+    const summary = getUsageSummary({
+      cwd: root,
+      tool: options.tool || "all",
+      limit: options.limit || 10,
+      allRepos: Boolean(options.allRepos),
+    });
+    const sessions = (summary.sessions || []).map((session) => {
+      const waste = estimateWaste(session);
+      return {
+        tool: session.tool || "unknown",
+        repo: repoBasename(session, root),
+        title: session.title || null,
+        model: session.model || null,
+        updatedAt: session.updatedAt || session.startedAt || null,
+        risk: session.contextRisk || "Unknown",
+        tokens: Number(waste.tokens || 0),
+        wastedTokens: Number(waste.wastedTokens || 0),
+        wastePercent: Number(waste.wastePercent || 0),
+        topCause: waste.topCause || "low-signal",
+        repeatedCommands: session.repeatedCommands || [],
+        repeatedPaths: session.repeatedPathMentions || [],
+        loopSuspicion: Boolean(session.loopSuspicion),
+      };
+    });
+    return { root, sessions, generatedAt: new Date().toISOString() };
+  }
+
+  function buildSessionsView(rootDir, options = {}) {
+    const { root, sessions, generatedAt } = collect(rootDir, options);
+    const totals = sessions.reduce((acc, s) => {
+      acc.sessions += 1;
+      acc.tokens += s.tokens;
+      acc.wastedTokens += s.wastedTokens;
+      return acc;
+    }, { sessions: 0, tokens: 0, wastedTokens: 0 });
+    totals.wastePercent = totals.tokens > 0 ? Math.round((totals.wastedTokens / totals.tokens) * 100) : 0;
+    return {
+      schemaVersion: 1,
+      command: "sessions",
+      scannedPath: root,
+      allRepos: Boolean(options.allRepos),
+      sessions: sessions.sort((a, b) => String(b.updatedAt || "").localeCompare(String(a.updatedAt || ""))),
+      totals,
+      generatedAt,
+    };
+  }
+
+  function renderSessionsTerminal(view) {
+    const lines = [];
+    lines.push("");
+    lines.push("PrismoDev Sessions");
+    lines.push("");
+    if (!view.sessions.length) {
+      lines.push("No recent local agent sessions found.");
+      lines.push(view.allRepos ? "" : "Tip: add --all-repos to look across every repo on this machine.");
+      return lines.join("\n").trimEnd();
+    }
+    for (const s of view.sessions) {
+      const when = s.updatedAt ? new Date(s.updatedAt).toLocaleString() : "unknown time";
+      lines.push(`${s.tool.padEnd(12)} ${s.repo}  ·  ${when}`);
+      lines.push(`  ${formatTokenCount(s.tokens)} tokens  |  ~${formatTokenCount(s.wastedTokens)} wasted (${s.wastePercent}%)  |  ${s.risk} risk  |  ${CAUSE_LABELS[s.topCause] || s.topCause}`);
+    }
+    lines.push("");
+    lines.push(`Totals: ${view.totals.sessions} session(s)  ·  ${formatTokenCount(view.totals.tokens)} tokens  ·  ~${formatTokenCount(view.totals.wastedTokens)} likely wasted (${view.totals.wastePercent}%)`);
+    return lines.join("\n");
+  }
+
+  function buildLocalReport(rootDir, options = {}) {
+    const { root, sessions, generatedAt } = collect(rootDir, { ...options, allRepos: options.allRepos });
+    const observed = sessions.reduce((sum, s) => sum + s.tokens, 0);
+    const wasted = sessions.reduce((sum, s) => sum + s.wastedTokens, 0);
+
+    const causeTotals = new Map();
+    for (const s of sessions) {
+      if (s.topCause === "low-signal") continue;
+      causeTotals.set(s.topCause, (causeTotals.get(s.topCause) || 0) + s.wastedTokens);
+    }
+    const topCauses = Array.from(causeTotals, ([cause, tokens]) => ({
+      cause,
+      label: CAUSE_LABELS[cause] || cause,
+      tokens,
+    })).sort((a, b) => b.tokens - a.tokens).slice(0, 5);
+
+    const repeatedReads = aggregate(sessions, (s) => s.repeatedPaths).slice(0, 5);
+    const repeatedCommands = aggregate(sessions, (s) => s.repeatedCommands).slice(0, 5);
+    const loopSessions = sessions.filter((s) => s.loopSuspicion).length;
+    const primaryCause = topCauses[0] ? topCauses[0].cause : "low-signal";
+
+    return {
+      schemaVersion: 1,
+      command: "report",
+      scannedPath: root,
+      allRepos: Boolean(options.allRepos),
+      sessions: sessions.length,
+      observedTokens: observed,
+      wastedTokens: wasted,
+      wastePercent: observed > 0 ? Math.round((wasted / observed) * 100) : 0,
+      topCauses,
+      repeatedReads,
+      repeatedCommands,
+      loopSessions,
+      nextAction: NEXT_ACTION[primaryCause] || NEXT_ACTION["low-signal"],
+      note: "Local estimate from your own session logs. Connect with `prismo connect` for verified, dollar-denominated savings.",
+      generatedAt,
+    };
+  }
+
+  function aggregate(sessions, pick) {
+    const totals = new Map();
+    for (const s of sessions) {
+      for (const item of pick(s) || []) {
+        if (!item || !item.value) continue;
+        totals.set(item.value, (totals.get(item.value) || 0) + Number(item.count || 0));
+      }
+    }
+    return Array.from(totals, ([value, count]) => ({ value, count })).sort((a, b) => b.count - a.count);
+  }
+
+  function renderLocalReportTerminal(report) {
+    const lines = [];
+    lines.push("");
+    lines.push("PrismoDev Report");
+    lines.push("");
+    if (!report.sessions) {
+      lines.push("No recent local agent sessions found.");
+      lines.push(report.allRepos ? "" : "Tip: add --all-repos to look across every repo on this machine.");
+      return lines.join("\n").trimEnd();
+    }
+    lines.push(`Observed: ${formatTokenCount(report.observedTokens)} tokens across ${report.sessions} session(s)`);
+    lines.push(`Likely wasted: ${formatTokenCount(report.wastedTokens)} (${report.wastePercent}%)`);
+    if (report.loopSessions) lines.push(`Loop-suspect sessions: ${report.loopSessions}`);
+    if (report.topCauses.length) {
+      lines.push("");
+      lines.push("Top causes:");
+      report.topCauses.forEach((c) => lines.push(`- ${c.label}: ~${formatTokenCount(c.tokens)} tokens`));
+    }
+    if (report.repeatedReads.length) {
+      lines.push("");
+      lines.push("Most repeated reads:");
+      report.repeatedReads.forEach((r) => lines.push(`- ${r.value} (${r.count}x)`));
+    }
+    if (report.repeatedCommands.length) {
+      lines.push("");
+      lines.push("Most repeated commands:");
+      report.repeatedCommands.forEach((r) => lines.push(`- ${r.value} (${r.count}x)`));
+    }
+    lines.push("");
+    lines.push(`Next: ${report.nextAction}`);
+    lines.push(report.note);
+    return lines.join("\n");
+  }
+
+  return {
+    buildSessionsView,
+    renderSessionsTerminal,
+    buildLocalReport,
+    renderLocalReportTerminal,
+  };
+};

package/lib/prismo-dev-scan.js

@@ -355,6 +355,18 @@ const {
   runFirewall,
 });
 
+const {
+  buildSessionsView,
+  renderSessionsTerminal,
+  buildLocalReport,
+  renderLocalReportTerminal,
+} = require("./prismo-dev/sessions-report")({
+  path,
+  getUsageSummary,
+  estimateWaste,
+  formatTokenCount,
+});
+
 const repairPlanner = require("./prismo-dev/repair-planner")({
   fs,
   path,
@@ -510,6 +522,10 @@ const { runCli } = require("./prismo-dev/cli")({
   runDisconnect,
   runStatus,
   runSync,
+  buildSessionsView,
+  renderSessionsTerminal,
+  buildLocalReport,
+  renderLocalReportTerminal,
   renderGuardTerminal,
   runGuard,
   REPAIR_CAUSES,

package/package.json

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