@echomem/mcp 1.4.7 → 1.4.9

package/dist/context-metrics/calculate.js

@@ -0,0 +1,56 @@
+export function calculateContextMetrics(input) {
+    const latestInputTokens = nonNegative(input.latestInputTokens);
+    const modelContextLimitTokens = optionalPositive(input.modelContextLimitTokens);
+    const currentResidentWasteTokens = nonNegative(input.currentResidentWasteTokens);
+    const currentResidentUsefulTokens = Math.max(0, latestInputTokens - currentResidentWasteTokens);
+    const newOutputThisTurnTokens = optionalNonNegative(input.newOutputThisTurnTokens);
+    const newWasteThisTurnTokens = optionalNonNegative(input.newWasteThisTurnTokens);
+    const contextFullnessPct = modelContextLimitTokens ? latestInputTokens / modelContextLimitTokens : undefined;
+    const noisePct = latestInputTokens > 0 ? currentResidentWasteTokens / latestInputTokens : 0;
+    const usefulPct = latestInputTokens > 0 ? currentResidentUsefulTokens / latestInputTokens : 0;
+    const projectedNextFullnessPct = modelContextLimitTokens && newOutputThisTurnTokens !== undefined
+        ? (latestInputTokens + newOutputThisTurnTokens) / modelContextLimitTokens
+        : undefined;
+    const healthScorePct = calculateHealthScorePct({
+        noisePct,
+        contextFullnessPct,
+        projectedNextFullnessPct,
+    });
+    return {
+        latestInputTokens,
+        modelContextLimitTokens,
+        currentResidentWasteTokens,
+        currentResidentUsefulTokens,
+        ...(newOutputThisTurnTokens !== undefined ? { newOutputThisTurnTokens } : {}),
+        ...(newWasteThisTurnTokens !== undefined ? { newWasteThisTurnTokens } : {}),
+        ...(contextFullnessPct !== undefined ? { contextFullnessPct } : {}),
+        noisePct,
+        usefulPct,
+        healthScorePct,
+        snr: currentResidentWasteTokens > 0 ? currentResidentUsefulTokens / currentResidentWasteTokens : null,
+        ...(projectedNextFullnessPct !== undefined ? { projectedNextFullnessPct } : {}),
+    };
+}
+function calculateHealthScorePct(input) {
+    const pressurePct = Math.max(input.contextFullnessPct ?? 0, input.projectedNextFullnessPct ?? 0);
+    // Noise is a direct quality loss. Fullness becomes a separate pressure penalty after 70% because
+    // clean-but-nearly-full sessions still become slow, brittle, or compaction-prone.
+    const fullnessPenaltyPct = pressurePct > 0.7
+        ? clamp01((pressurePct - 0.7) / 0.3) * 35
+        : 0;
+    return Math.max(0, Math.min(100, Math.round(100 - input.noisePct * 100 - fullnessPenaltyPct)));
+}
+function nonNegative(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.round(value)) : 0;
+}
+function optionalNonNegative(value) {
+    return value === undefined ? undefined : nonNegative(value);
+}
+function optionalPositive(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return null;
+    return Math.round(value);
+}
+function clamp01(value) {
+    return Math.max(0, Math.min(1, value));
+}

package/dist/context-metrics/model-limits.js

@@ -0,0 +1,26 @@
+const MODEL_CONTEXT_LIMITS = [
+    // Claude transcript logs do not carry context_window_size, so use the published family limit only
+    // as an explicit fallback. Codex logs should prefer their per-call model_context_window field.
+    { match: /^claude-(?:opus|sonnet|haiku|fable)-4/i, tokens: 200_000 },
+];
+export function modelContextLimitTokensFor(model) {
+    const name = String(model || "").trim();
+    if (!name)
+        return null;
+    const found = MODEL_CONTEXT_LIMITS.find((entry) => entry.match.test(name));
+    return found?.tokens ?? null;
+}
+export function resolveModelContextLimit(params) {
+    const logged = positive(params.loggedLimitTokens);
+    if (logged)
+        return { tokens: logged, source: "logged" };
+    const fallback = modelContextLimitTokensFor(params.model);
+    if (fallback)
+        return { tokens: fallback, source: "model-default" };
+    return { tokens: null, source: "unavailable" };
+}
+function positive(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return null;
+    return Math.round(value);
+}

package/dist/context-metrics/types.js

@@ -0,0 +1 @@
+export {};

package/dist/forensics-10-problems.js

@@ -24,9 +24,10 @@
  *
  * All data stays local. No LLM calls. Transcripts never leave the machine.
  */
-import os from "node:os";
 import path from "node:path";
 import { eachLine, walk } from "./report.js";
+import { discoverCodexSessionFiles } from "./codex-session-files.js";
+import { resolveClaudeProjectsDir } from "./local-data-paths.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -584,11 +585,11 @@ function aggregateResults(sessionResults, firstTs, lastTs) {
 // ---------------------------------------------------------------------------
 export function buildProblemReport(opts) {
     const sources = opts?.sources ?? ["codex", "claude"];
-    const codexFiles = sources.includes("codex")
-        ? walk(path.join(os.homedir(), ".codex", "sessions"), (p) => /rollout-.*\.jsonl$/.test(p), () => false).sort()
-        : [];
-    const claudeFiles = sources.includes("claude")
-        ? walk(path.join(os.homedir(), ".claude", "projects"), (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows").sort()
+    const codexDiscovery = sources.includes("codex") ? discoverCodexSessionFiles({ includeArchived: true }) : null;
+    const claudeRoot = sources.includes("claude") ? resolveClaudeProjectsDir() : null;
+    const codexFiles = codexDiscovery?.files.map((file) => file.path) ?? [];
+    const claudeFiles = claudeRoot
+        ? walk(claudeRoot, (p) => p.endsWith(".jsonl"), (name) => name === "subagents" || name === "workflows").sort()
         : [];
     const total = codexFiles.length + claudeFiles.length;
     let done = 0;