knit-mcp 0.7.1 → 0.9.0

package/README.md

@@ -59,6 +59,27 @@ Adds the Knit MCP server to your Claude Code config (`~/.claude.json`). No per-p
 
 **Supported shells:** macOS, Linux, WSL, Git Bash, and Windows PowerShell. The generated hooks use POSIX-style single-quoted `node -e '…'` payloads. Windows `cmd.exe` does not treat single quotes as delimiters and is not supported as the hook-runner shell — on Windows, use PowerShell (default in modern Windows Terminal) or Git Bash. If you hit a hook error on Windows, file an issue with the shell you're using.
 
+### Quiet mode (no hook enforcement)
+
+Knit ships Protocol Guard in `warn` mode by default — hooks print reminders, they never block. If you want it fully silent (no PreToolUse classification gate, no reminder messages), run this once inside Claude Code:
+
+> `knit_set_protocol_strictness({ level: "off" })`
+
+The other hooks (LEARN compliance, KB metrics, final build verification) stay as observability nudges — they print, they don't gate. To remove them too, see Uninstall below.
+
+### Uninstall
+
+```bash
+rm -rf ~/.knit                                 # all per-project + global memory
+```
+
+Then:
+1. Remove `"knit-brain"` from `mcpServers` in `~/.claude.json`
+2. Delete the `<!-- knit:start --> ... <!-- knit:end -->` block from each project's `CLAUDE.md`
+3. Remove `_knitOwned` entries from each project's `.claude/settings.local.json` (or delete the file if Knit was the only thing in it)
+
+Total time: ~30 seconds per project. Knit doesn't write anywhere else on your machine.
+
 ## How data is stored
 
 Knit data is centralized — not in every repo's working tree:

package/dist/{cache-BVFD5F5Y.js → cache-JSN6ETUF.js}

@@ -2,13 +2,15 @@ import {
   detectProjectRoot,
   getBrain,
   refreshBrain
-} from "./chunk-X6TGTET3.js";
-import "./chunk-3XR77YJM.js";
-import "./chunk-SLN5ABF5.js";
+} from "./chunk-4K4FHOKE.js";
+import "./chunk-BU3VHX3W.js";
+import "./chunk-MOOVNMIN.js";
 import "./chunk-7PPC6IG6.js";
 import "./chunk-M3YZOJNW.js";
+import "./chunk-FLNV2IQC.js";
+import "./chunk-KLNUEE3O.js";
 import "./chunk-BAUQEFYY.js";
-import "./chunk-HBMF62U4.js";
+import "./chunk-XFS2XGZI.js";
 export {
   detectProjectRoot,
   getBrain,

package/dist/{chunk-X6TGTET3.js → chunk-4K4FHOKE.js}

@@ -1,20 +1,27 @@
 import {
   installAgentsForProject,
+  prewarmLatestVersion,
   pruneSessionsByAge
-} from "./chunk-3XR77YJM.js";
+} from "./chunk-BU3VHX3W.js";
 import {
-  KNIT_MARKER_START,
   buildKnowledge,
-  buildReverseDependencies,
-  generateClaudeMd,
-  spliceKnitBlock
-} from "./chunk-SLN5ABF5.js";
+  buildReverseDependencies
+} from "./chunk-MOOVNMIN.js";
 import {
   scanProject
 } from "./chunk-7PPC6IG6.js";
 import {
   readLearnings
 } from "./chunk-M3YZOJNW.js";
+import {
+  persistScanResult,
+  scanIntegrations
+} from "./chunk-FLNV2IQC.js";
+import {
+  KNIT_MARKER_START,
+  generateClaudeMd,
+  spliceKnitBlock
+} from "./chunk-KLNUEE3O.js";
 import {
   importFromMarkdown,
   loadKnowledgeBase,
@@ -34,11 +41,12 @@ import {
   migrationBreadcrumbPath,
   projectDataDir,
   protocolConfigPath,
+  searchMarkerPath,
   sessionMarkerPath,
   sessionsJsonlPath,
   sessionsLogPath,
   teamsPath
-} from "./chunk-HBMF62U4.js";
+} from "./chunk-XFS2XGZI.js";
 
 // src/mcp/cache.ts
 import { execSync } from "child_process";
@@ -65,7 +73,7 @@ function generateLearningsContent(config) {
 }
 
 // src/generators/settings.ts
-var HOOKS_VERSION = 6;
+var HOOKS_VERSION = 7;
 function generateSettings(config, rootPath) {
   return {
     mcpServers: {
@@ -111,6 +119,9 @@ function generateHooks(config, rootPath) {
   const PROTOCOL_CONFIG = protocolConfigPath(rootPath);
   const CLASSIFIED_MARKER = classificationMarkerPath(rootPath);
   const SESSION_MARKER = sessionMarkerPath(rootPath);
+  const SEARCH_MARKER = searchMarkerPath(rootPath);
+  const CLAUDE_MD = `${rootPath}/CLAUDE.md`;
+  void knowledgePath;
   const hooks = {
     SessionStart: [
       // Protocol Guard layer 1: drop a marker that knit_load_session
@@ -149,6 +160,10 @@ function generateHooks(config, rootPath) {
                 const fs = require("fs");
                 const p = ${jsLit(CLASSIFIED_MARKER)};
                 if (fs.existsSync(p)) fs.rmSync(p, { force: true });
+                // v0.9 #5: per-turn search marker is also cleared at the turn boundary
+                // so the next non-trivial task has to call knit_search_learnings again.
+                const sm = ${jsLit(SEARCH_MARKER)};
+                if (fs.existsSync(sm)) fs.rmSync(sm, { force: true });
               } catch (e) {}
             `),
             timeout: 5
@@ -192,6 +207,7 @@ function generateHooks(config, rootPath) {
                 const fs = require("fs");
                 const cfgPath = ${jsLit(PROTOCOL_CONFIG)};
                 const markerPath = ${jsLit(CLASSIFIED_MARKER)};
+                const searchMarkerPath = ${jsLit(SEARCH_MARKER)};
                 let level = "warn";
                 if (fs.existsSync(cfgPath)) {
                   try {
@@ -202,13 +218,33 @@ function generateHooks(config, rootPath) {
                   }
                 }
                 if (level === "off") return;
+                // Classification gate (v0.5).
                 const hasMarker = fs.existsSync(markerPath);
-                if (hasMarker) return;
-                if (level === "block") {
-                  console.error("[knit] BLOCKED: call knit_classify_task before Edit/Write. The Protocol Guard prevents implementation without classification.");
-                  process.exit(2);
+                if (!hasMarker) {
+                  if (level === "block") {
+                    console.error("[knit] BLOCKED: call knit_classify_task before Edit/Write. The Protocol Guard prevents implementation without classification.");
+                    process.exit(2);
+                  }
+                  console.error("[knit] reminder: call knit_classify_task before Edit/Write. Set strictness=block via knit_set_protocol_strictness to make this a hard gate.");
+                  return;
+                }
+                // v0.9 #5: search gate. For standard/complex tasks, knit_search_learnings
+                // (or knit_search_global_learnings) must run before the Edit lands \u2014
+                // otherwise the agent is re-investigating without checking memory.
+                try {
+                  const marker = JSON.parse(fs.readFileSync(markerPath, "utf-8"));
+                  if (marker && (marker.tier === "standard" || marker.tier === "complex")) {
+                    if (!fs.existsSync(searchMarkerPath)) {
+                      if (level === "block") {
+                        console.error("[knit] BLOCKED: " + marker.tier + " task \u2014 call knit_search_learnings or knit_search_global_learnings before Edit/Write so memory is checked before re-investigation.");
+                        process.exit(2);
+                      }
+                      console.error("[knit] reminder: " + marker.tier + " task \u2014 call knit_search_learnings before Edit/Write. Skipping memory check means re-doing work the project already learned.");
+                    }
+                  }
+                } catch (markerErr) {
+                  // Marker exists but JSON unreadable \u2014 be lenient.
                 }
-                console.error("[knit] reminder: call knit_classify_task before Edit/Write. Set strictness=block via knit_set_protocol_strictness to make this a hard gate.");
               } catch (hookErr) {
                 console.error("[knit] protocol-guard hook crashed, allowing tool through:", hookErr && hookErr.message ? hookErr.message : hookErr);
               }
@@ -216,11 +252,106 @@ function generateHooks(config, rootPath) {
             timeout: 5
           }
         ]
+      },
+      // v0.9 #9 — Pre-write content inspection. Reads the proposed Write/Edit
+      // content from tool_input, parses local import statements, and reports
+      // any relative paths that don't resolve on disk. Warn-level by default
+      // (the existing classification gate handles block mode); soft signal,
+      // never blocks on its own.
+      {
+        _knitOwned: true,
+        matcher: "Write|Edit|MultiEdit",
+        hooks: [
+          {
+            type: "command",
+            command: nodeHook(`
+              let d = "";
+              process.stdin.on("data", (c) => d += c);
+              process.stdin.on("end", () => {
+                try {
+                  const fs = require("fs");
+                  const path = require("path");
+                  const i = JSON.parse(d);
+                  const filePath = (i.tool_input && i.tool_input.file_path) || "";
+                  if (!/\\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(filePath)) return;
+                  // Pull proposed content from any of the Edit/Write shapes.
+                  let content = (i.tool_input && (i.tool_input.content || i.tool_input.new_string)) || "";
+                  if (i.tool_input && Array.isArray(i.tool_input.edits)) {
+                    content = i.tool_input.edits.map((e) => e && e.new_string ? e.new_string : "").join("\\n");
+                  }
+                  if (!content) return;
+                  const dir = path.dirname(filePath);
+                  const re = /^import\\s+(?:[^'"]+?\\s+from\\s+)?['"]([^'"]+)['"]/gm;
+                  const unresolved = [];
+                  let m;
+                  while ((m = re.exec(content)) !== null) {
+                    const target = m[1];
+                    if (!target.startsWith(".") && !target.startsWith("/")) continue;
+                    const candidates = [target, target + ".ts", target + ".tsx", target + ".js", target + ".jsx", target + "/index.ts", target + "/index.tsx", target + "/index.js"];
+                    let resolved = false;
+                    for (const c of candidates) {
+                      const abs = path.resolve(dir, c);
+                      if (fs.existsSync(abs)) { resolved = true; break; }
+                    }
+                    if (!resolved) unresolved.push(target);
+                  }
+                  if (unresolved.length > 0) {
+                    console.error("[knit] heads-up: proposed edit references " + unresolved.length + " unresolved relative import(s): " + unresolved.join(", ") + ". Likely hallucinated paths \u2014 verify with knit_query_imports or knit_verify_claim before relying on them.");
+                  }
+                } catch (e) {}
+              });
+            `),
+            timeout: 5
+          }
+        ]
       }
     ],
     PostToolUse: [],
     Stop: []
   };
+  hooks.PostToolUse.push({
+    _knitOwned: true,
+    matcher: "Write|Edit|MultiEdit",
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          let d = "";
+          process.stdin.on("data", (c) => d += c);
+          process.stdin.on("end", () => {
+            try {
+              const fs = require("fs");
+              const path = require("path");
+              const i = JSON.parse(d);
+              const f = (i.tool_input && i.tool_input.file_path) || (i.tool_response && i.tool_response.filePath) || "";
+              if (!/\\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(f)) return;
+              if (!fs.existsSync(f)) return;
+              const content = fs.readFileSync(f, "utf-8");
+              const dir = path.dirname(f);
+              const re = /^import\\s+(?:[^'"]+?\\s+from\\s+)?['"]([^'"]+)['"]/gm;
+              const unresolved = [];
+              let m;
+              while ((m = re.exec(content)) !== null) {
+                const target = m[1];
+                if (!target.startsWith(".") && !target.startsWith("/")) continue;
+                const candidates = [target, target + ".ts", target + ".tsx", target + ".js", target + ".jsx", target + "/index.ts", target + "/index.tsx", target + "/index.js"];
+                let resolved = false;
+                for (const c of candidates) {
+                  if (fs.existsSync(path.resolve(dir, c))) { resolved = true; break; }
+                }
+                if (!resolved) unresolved.push(target);
+              }
+              if (unresolved.length > 0) {
+                console.error("[knit] post-write check: " + f + " has " + unresolved.length + " unresolved relative import(s): " + unresolved.join(", ") + ". Run typecheck before relying on this file.");
+              }
+            } catch (e) {}
+          });
+        `),
+        timeout: 5,
+        statusMessage: "Knit: validating imports..."
+      }
+    ]
+  });
   if (config.stack.language === "typescript" && config.stack.typecheckCommand) {
     hooks.PostToolUse.push({
       _knitOwned: true,
@@ -351,6 +482,27 @@ function generateHooks(config, rootPath) {
       ]
     });
   }
+  hooks.Stop.push({
+    _knitOwned: true,
+    hooks: [
+      {
+        type: "command",
+        command: nodeHook(`
+          try {
+            const fs = require("fs");
+            const p = ${jsLit(CLAUDE_MD)};
+            if (!fs.existsSync(p)) return;
+            const size = fs.statSync(p).size;
+            if (size > 12500) {
+              console.error("[knit] budget watch: CLAUDE.md is " + Math.round(size/1024*10)/10 + "KB (target 6.5KB; over-budget threshold 12.5KB). Call knit_brain_status to confirm and consider regenerating via knit refresh.");
+            }
+          } catch (e) {}
+        `),
+        timeout: 5,
+        statusMessage: "Knit: budget check..."
+      }
+    ]
+  });
   hooks.Stop.push({
     _knitOwned: true,
     hooks: [
@@ -497,6 +649,7 @@ function getBrain(rootPath) {
   if (cache && cache.rootPath === rootPath) {
     return cache;
   }
+  void prewarmLatestVersion();
   let autoInitialized = false;
   const haveCentralized = existsSync(knowledgePath(rootPath));
   const haveLegacy = existsSync(legacyKnowledgePath(rootPath));
@@ -563,6 +716,16 @@ function autoInitialize(rootPath) {
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       process.stderr.write(`[knit] session prune background error: ${msg}
+`);
+    }
+  });
+  Promise.resolve().then(() => {
+    try {
+      const result = scanIntegrations(rootPath);
+      persistScanResult(rootPath, result);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stderr.write(`[knit] integration scan background error: ${msg}
 `);
     }
   });

package/dist/chunk-5NCSZYRJ.js

@@ -0,0 +1,66 @@
+// src/mcp/instructions.ts
+var KNIT_INSTRUCTIONS_BASE = `Knit is a memory + workflow layer for this project. It provides per-project memory across sessions, a knowledge graph (imports/exports/tests), and a tier-routed workflow protocol.
+
+ALWAYS at session start:
+1. Call knit_load_session \u2014 returns prior handoff, top learnings, false positives. If has_unfinished_work is true, resume that handoff instead of starting fresh.
+2. For any non-trivial task, call knit_classify_task BEFORE editing or writing \u2014 returns tier (inquiry / trivial / standard / complex) and phases.
+3. If tier=complex with auto_plan_mode=true, call EnterPlanMode immediately. Do not start editing.
+4. If tier=inquiry, just answer \u2014 no plan mode, no phases. Re-classify only if scope grows into writes.
+5. Before reporting a task done, call knit_record_learning if anything non-obvious surfaced (not a substring restatement of prior learnings).
+
+When to reach for other Knit tools:
+- knit_query_imports / knit_query_exports / knit_query_dependents / knit_query_tests \u2014 use instead of grep when the knowledge index is fresh.
+- knit_search_learnings \u2014 call before re-investigating a domain. The point of memory is to skip what you've already learned.
+- knit_search_sessions \u2014 answers "have I done this before?"
+- knit_search_global_learnings \u2014 same, but across all your projects (Knit's cross-project pool).
+- knit_get_workflow({phase}) \u2014 fetch protocol depth for one phase on demand. Do not try to remember the workflow; ask for it.
+- knit_list_features \u2014 if you want to do X but the tool isn't visible, this surfaces what's hidden and how to enable it.
+- knit_save_handoff \u2014 call when context degrades or session ends so the next session resumes cleanly.
+
+The protocol enforces a 4-tier classifier:
+- Inquiry: read-only "what / where / audit / explain" \u2014 just answer.
+- Trivial: single-file obvious change \u2014 EXECUTE \u2192 VERIFY \u2192 LEARN.
+- Standard: bug fix or single-domain feature \u2014 RESEARCH \u2192 EXECUTE \u2192 OPTIMIZE \u2192 REVIEW \u2192 LEARN.
+- Complex: cross-domain, types/auth-touching, high-fanout, or any task spanning more than one commit \u2014 full 6 phases with auto plan mode on RESEARCH.
+
+Knit provides inputs; you make the calls. When in doubt, under-classify \u2014 easier to escalate mid-task than to downgrade.
+
+Citation rule: when you state a fact about this codebase ("file X imports Y", "function Z is defined in W", "tests for A live in B"), cite the Knit tool result that verified it \u2014 e.g. "(per knit_query_imports)". If you can't cite a tool result, mark the claim as 'unverified' explicitly. This makes hallucinations visible at the claim level instead of letting them ship as confident-sounding prose. The verifier exists; use it.`;
+var KNIT_INSTRUCTIONS = KNIT_INSTRUCTIONS_BASE;
+function buildInstructions(scan) {
+  if (!scan) return KNIT_INSTRUCTIONS_BASE;
+  const addenda = [];
+  if (scan.detected.ruflo.present) {
+    addenda.push(
+      "DETECTED: Ruflo (multi-agent orchestration) is installed alongside Knit on this project. For multi-agent swarms, federation, or large-scale orchestration, defer to Ruflo's tools (`memory_store`, `swarm_init`, `agent_spawn`, etc). Knit's domain in this project: per-project memory + tier-routed classification + token discipline. Do NOT duplicate Ruflo's routing logic with Knit's tier protocol when Ruflo is driving the workflow."
+    );
+  }
+  if (scan.detected.gstack.present) {
+    addenda.push(
+      "DETECTED: gstack slash commands are installed. For routing decisions (`/plan`, `/ship`, `/qa`, `/cso`, `/investigate`), prefer the gstack command. Knit operates underneath as the memory + classification layer; the gstack command can invoke Knit tools internally."
+    );
+  }
+  if (scan.detected.codetour.present) {
+    addenda.push(
+      "DETECTED: CodeTour is configured (.tours/*.tour). When asked to walk through code or explain architecture, surface relevant tours via the CodeTour extension rather than reconstructing the explanation from scratch."
+    );
+  }
+  if (scan.detected.conductor.present) {
+    addenda.push(
+      "DETECTED: Conductor is installed. For cross-workspace handoff and context-restore flows, defer to Conductor's primitives; Knit's `knit_save_handoff` / `knit_load_session` continue to handle the per-project memory layer."
+    );
+  }
+  if (scan.detected.custom_workflow_sections.length > 0) {
+    addenda.push(
+      `DETECTED: this project's CLAUDE.md has user-curated workflow sections (${scan.detected.custom_workflow_sections.join("; ")}). Treat that as the canonical workflow doc for project-specific phases; Knit's tier protocol applies underneath as the routing layer.`
+    );
+  }
+  if (addenda.length === 0) return KNIT_INSTRUCTIONS_BASE;
+  return KNIT_INSTRUCTIONS_BASE + "\n\n\u2014 Per-project integrations \u2014\n\n" + addenda.join("\n\n") + "\n\nGeneral rule: when an integration above provides a higher-level routing primitive (slash command, swarm orchestrator, methodology framework), use it. Knit handles the substrate it doesn't cover: memory, classification, and the workflow protocol for tasks the integration doesn't route.";
+}
+
+export {
+  KNIT_INSTRUCTIONS_BASE,
+  KNIT_INSTRUCTIONS,
+  buildInstructions
+};

package/dist/{chunk-TRZ3LD6B.js → chunk-B2KZ5UR7.js}

@@ -2,7 +2,7 @@ import {
   canonicalRepoRoot,
   globalLearningsPath,
   projectId
-} from "./chunk-HBMF62U4.js";
+} from "./chunk-XFS2XGZI.js";
 
 // src/engine/global-learnings.ts
 import { existsSync, mkdirSync, appendFileSync, readFileSync, statSync } from "fs";
@@ -44,6 +44,15 @@ function getRecentGlobalLearnings(n = 5) {
   }
   return out;
 }
+function loadAllGlobalLearnings() {
+  const lines = readAllLines();
+  const out = [];
+  for (const line of lines) {
+    const entry = parseLine(line);
+    if (entry) out.push(entry);
+  }
+  return out;
+}
 function buildGlobalLearning(sourceProjectRoot, payload) {
   return {
     id: payload.id ?? `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
@@ -83,5 +92,6 @@ export {
   appendGlobalLearning,
   searchGlobalLearnings,
   getRecentGlobalLearnings,
+  loadAllGlobalLearnings,
   buildGlobalLearning
 };

package/dist/{chunk-3XR77YJM.js → chunk-BU3VHX3W.js}

@@ -11,7 +11,7 @@ import {
   projectAgentFile,
   projectAgentsDir,
   sessionsJsonlPath
-} from "./chunk-HBMF62U4.js";
+} from "./chunk-XFS2XGZI.js";
 
 // src/engine/install-agents.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -285,6 +285,55 @@ function agentsNeededByProject(config) {
   return Array.from(names);
 }
 
+// src/mcp/update-check.ts
+var REGISTRY_DIST_TAGS_URL = "https://registry.npmjs.org/-/package/knit-mcp/dist-tags";
+var FETCH_TIMEOUT_MS = 2e3;
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+var cachedLatest = null;
+var lastCheckedAt = 0;
+var inFlight = null;
+function getCachedLatestVersion() {
+  if (Date.now() - lastCheckedAt > CACHE_TTL_MS) {
+    prewarmLatestVersion();
+  }
+  return cachedLatest;
+}
+function prewarmLatestVersion() {
+  if (inFlight) return;
+  if (Date.now() - lastCheckedAt < CACHE_TTL_MS && cachedLatest !== null) return;
+  inFlight = doFetch().finally(() => {
+    inFlight = null;
+  });
+}
+async function doFetch() {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(REGISTRY_DIST_TAGS_URL, { signal: controller.signal });
+    if (!res.ok) return;
+    const data = await res.json();
+    if (typeof data.latest === "string" && data.latest.length > 0) {
+      cachedLatest = data.latest;
+      lastCheckedAt = Date.now();
+    }
+  } catch {
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function isNewerVersion(latest, current) {
+  const parse = (v) => {
+    const stripped = v.replace(/[-+].*$/, "");
+    const parts = stripped.split(".").map((n) => parseInt(n, 10) || 0);
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+  };
+  const [a1, a2, a3] = parse(latest);
+  const [b1, b2, b3] = parse(current);
+  if (a1 !== b1) return a1 > b1;
+  if (a2 !== b2) return a2 > b2;
+  return a3 > b3;
+}
+
 // src/engine/sessions.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, appendFileSync, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync3, renameSync } from "fs";
 import { dirname as dirname2 } from "path";
@@ -327,6 +376,15 @@ function getRecentSessions(rootPath, n = 3) {
 function sessionCount(rootPath) {
   return readAllLines(rootPath).length;
 }
+function loadAllSessions(rootPath) {
+  const lines = readAllLines(rootPath);
+  const out = [];
+  for (const line of lines) {
+    const entry = parseLine(line);
+    if (entry) out.push(entry);
+  }
+  return out;
+}
 function pruneSessionsByAge(rootPath, maxAgeDays) {
   const path = sessionsJsonlPath(rootPath);
   if (!existsSync3(path)) return { kept: 0, pruned: 0 };
@@ -400,9 +458,13 @@ function parseLine(line) {
 
 export {
   installAgentsForProject,
+  getCachedLatestVersion,
+  prewarmLatestVersion,
+  isNewerVersion,
   appendSession,
   searchSessions,
   getRecentSessions,
   sessionCount,
+  loadAllSessions,
   pruneSessionsByAge
 };