@papyruslabsai/seshat-mcp 0.10.0 → 0.11.1

package/dist/index.js

@@ -33,6 +33,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { MultiLoader } from './loader.js';
 import { bootstrap } from './bootstrap.js';
+import { logTelemetry, isSupabaseConfigured } from './supabase.js';
 import { initTools, queryEntities, getEntity, getDependencies, getDataFlow, findByConstraint, getBlastRadius, listModules, getTopology, } from './tools/index.js';
 import { findDeadCode, findLayerViolations, getCouplingMetrics, getAuthMatrix, findErrorGaps, getTestCoverage, getOptimalContext, estimateTaskCost, reportActualBurn, find_runtime_violations, find_ownership_violations, query_traits, simulate_mutation, query_data_targets, find_exposure_leaks, find_semantic_clones, create_symbol, } from './tools/functors.js';
 import { diffBundle, conflictMatrix, } from './tools/diff.js';
@@ -542,7 +543,7 @@ const TOOLS = [
     },
     {
         name: 'conflict_matrix',
-        description: 'Given multiple tasks, classify every task pair into conflict tiers to determine parallelization safety. Tier 1 (different files, safe), Tier 2 (same file, different symbols, safe), Tier 3 (same symbol, orthogonal changes like imports vs logic, risky but parallelizable), Tier 4 (same symbol, overlapping changes, MUST sequence). Passing "scopes" per task enables Tier 3 downgrades.',
+        description: 'Given multiple tasks, classify every task pair into conflict tiers to determine parallelization safety. Tier 1 (different files, safe), Tier 2 (same file, different symbols, safe via surgical splicing), Tier 3 (same symbol, MUST sequence to maintain splice integrity). Returns a pairwise matrix and a suggested execution plan.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -564,7 +565,7 @@ const TOOLS = [
                             dimensions: {
                                 type: 'array',
                                 items: { type: 'string' },
-                                description: 'Optional: Code scopes this task will modify (e.g., "edges", "struct", "semantics", "constraints"). Used to downgrade conflicts via spatial separation.',
+                                description: 'Optional: Code scopes this task will modify. (Legacy support, no longer required for Tier 2 safety).',
                             },
                             expand_blast_radius: {
                                 type: 'boolean',
@@ -647,6 +648,7 @@ async function main() {
     // Handle tool calls
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
+        const startTime = Date.now();
         try {
             if (!loader.isLoaded()) {
                 return {
@@ -659,8 +661,7 @@ async function main() {
                 };
             }
             let result;
-            switch (name) {
-                // Meta
+            switch (name) { // Meta
                 case 'list_projects':
                     result = {
                         multiProject: isMulti,
@@ -759,6 +760,21 @@ async function main() {
                 default:
                     result = { error: `Unknown tool: ${name}` };
             }
+            // Log telemetry for the tool execution
+            if (isSupabaseConfigured() && name !== 'list_projects') {
+                const executionMs = Date.now() - startTime;
+                const projectHash = args && typeof args === 'object' && 'project' in args
+                    ? String(args.project)
+                    : loader.getProjectNames()[0] || 'unknown';
+                // Fire-and-forget telemetry log
+                logTelemetry({
+                    tool_name: name,
+                    project_hash: projectHash,
+                    execution_ms: executionMs,
+                    // user_id will be added by the Ptah API gateway if passing through there,
+                    // or stay null if running strictly local CLI without an injected token.
+                }).catch(() => { });
+            }
             return {
                 content: [{
                         type: 'text',

package/dist/loader.d.ts

@@ -11,7 +11,13 @@ export declare class BundleLoader {
     private manifest;
     private loaded;
     private seshatDir;
+    private bundleMtime;
     constructor(cwd?: string);
+    /**
+     * Check if the bundle file on disk has changed since last load.
+     * If so, reload transparently. Called by all accessors.
+     */
+    private ensureFresh;
     load(): void;
     getEntities(): JstfEntity[];
     getTopology(): Topology | null;
@@ -33,6 +39,7 @@ export declare class MultiLoader {
     private dirs;
     constructor(projectDirs: string[]);
     load(): void;
+    private loadProject;
     /** Get the resolved project name when only one project is loaded. */
     private defaultProject;
     private resolveProject;

package/dist/loader.js

@@ -12,10 +12,32 @@ export class BundleLoader {
     manifest = null;
     loaded = false;
     seshatDir;
+    bundleMtime = 0;
     constructor(cwd) {
         const root = cwd || process.cwd();
         this.seshatDir = path.join(root, '.seshat');
     }
+    /**
+     * Check if the bundle file on disk has changed since last load.
+     * If so, reload transparently. Called by all accessors.
+     */
+    ensureFresh() {
+        if (!this.loaded) {
+            this.load();
+            return;
+        }
+        const bundlePath = path.join(this.seshatDir, '_bundle.json');
+        try {
+            const currentMtime = fs.statSync(bundlePath).mtimeMs;
+            if (currentMtime !== this.bundleMtime) {
+                process.stderr.write(`[seshat] Bundle changed on disk, reloading…\n`);
+                this.load();
+            }
+        }
+        catch {
+            // File may have been deleted — keep stale data rather than crash
+        }
+    }
     load() {
         const bundlePath = path.join(this.seshatDir, '_bundle.json');
         if (!fs.existsSync(bundlePath)) {
@@ -24,6 +46,7 @@ export class BundleLoader {
                 `  node ci/extract-and-generate.mjs <repo-path> .seshat <project-name>\n` +
                 `Or add the CI workflow to auto-generate on push to main.`);
         }
+        this.bundleMtime = fs.statSync(bundlePath).mtimeMs;
         const raw = fs.readFileSync(bundlePath, 'utf-8');
         const bundle = JSON.parse(raw);
         this.entities = bundle.entities || [];
@@ -52,18 +75,15 @@ export class BundleLoader {
         this.loaded = true;
     }
     getEntities() {
-        if (!this.loaded)
-            this.load();
+        this.ensureFresh();
         return this.entities;
     }
     getTopology() {
-        if (!this.loaded)
-            this.load();
+        this.ensureFresh();
         return this.topology;
     }
     getManifest() {
-        if (!this.loaded)
-            this.load();
+        this.ensureFresh();
         return this.manifest;
     }
     getEntityById(id) {
@@ -96,26 +116,29 @@ export class MultiLoader {
     }
     load() {
         for (const dir of this.dirs) {
-            const loader = new BundleLoader(dir);
-            try {
-                loader.load();
-                const manifest = loader.getManifest();
-                const name = manifest?.projectName || path.basename(dir);
-                this.projects.set(name, loader);
-                this.projectPaths.set(name, dir);
-                // Stamp entities with _project
-                const entities = loader.getEntities();
-                for (const e of entities) {
-                    e._project = name;
-                }
-                this.projectEntities.set(name, entities);
-            }
-            catch (err) {
-                process.stderr.write(`Warning: Skipping ${dir}: ${err.message}\n`);
-            }
+            this.loadProject(dir);
         }
         this.loaded = true;
     }
+    loadProject(dir) {
+        const loader = new BundleLoader(dir);
+        try {
+            loader.load();
+            const manifest = loader.getManifest();
+            const name = manifest?.projectName || path.basename(dir);
+            this.projects.set(name, loader);
+            this.projectPaths.set(name, dir);
+            // Stamp entities with _project
+            const entities = loader.getEntities();
+            for (const e of entities) {
+                e._project = name;
+            }
+            this.projectEntities.set(name, entities);
+        }
+        catch (err) {
+            process.stderr.write(`Warning: Skipping ${dir}: ${err.message}\n`);
+        }
+    }
     /** Get the resolved project name when only one project is loaded. */
     defaultProject() {
         if (this.projects.size === 1)
@@ -129,9 +152,22 @@ export class MultiLoader {
         if (!this.loaded)
             this.load();
         const p = this.resolveProject(project);
-        if (p)
-            return this.projectEntities.get(p) || [];
-        return []; // multi-project with no project specified
+        if (!p)
+            return [];
+        // Delegate to BundleLoader (which checks mtime via ensureFresh),
+        // then re-stamp and cache if the reference changed.
+        const loader = this.projects.get(p);
+        if (!loader)
+            return [];
+        const fresh = loader.getEntities();
+        const cached = this.projectEntities.get(p);
+        if (fresh !== cached) {
+            for (const e of fresh) {
+                e._project = p;
+            }
+            this.projectEntities.set(p, fresh);
+        }
+        return fresh;
     }
     getTopology(project) {
         if (!this.loaded)

package/dist/supabase.d.ts

@@ -55,6 +55,31 @@ export interface TokenPredictionRow {
     session_id: string | null;
     notes: string | null;
 }
+export interface McpTelemetryLog {
+    user_id?: string;
+    tool_name: string;
+    project_hash: string;
+    execution_ms: number;
+}
+export interface JstfSnapshotInsert {
+    user_id?: string;
+    project_hash: string;
+    commit_sha: string;
+    language_primary: string;
+    total_entities: number;
+    metric_typeless_interfaces: number;
+    metric_max_in_degree: number;
+    metric_circular_dependencies: number;
+    metric_untracked_data_transformations: number;
+    metric_exposure_leaks: number;
+    metric_layer_violations: number;
+    metric_ownership_violations: number;
+    metric_impure_ratio: number;
+    metric_runtime_violations: number;
+    metric_semantic_clones: number;
+    metric_core_fragility_score: number;
+    bundle_payload: unknown;
+}
 /**
  * Insert a prediction row. Returns the row ID or null on failure.
  */
@@ -70,4 +95,5 @@ export declare function abandonPrediction(predictionId: string): Promise<boolean
 /**
  * List recent predictions for a project (for calibration analysis).
  */
-export declare function listPredictions(project?: string, limit?: number): Promise<TokenPredictionRow[]>;
+export declare function logTelemetry(log: McpTelemetryLog): Promise<void>;
+export declare function insertJstfSnapshot(snapshot: JstfSnapshotInsert): Promise<boolean>;

package/dist/supabase.js

@@ -18,7 +18,9 @@ export function isSupabaseConfigured() {
     return SUPABASE_URL.length > 0 && SUPABASE_KEY.length > 0;
 }
 // ─── REST helpers ────────────────────────────────────────────────
-const TABLE = 'mcp_token_predictions';
+const TABLE_PREDICTIONS = 'mcp_token_predictions';
+const TABLE_TELEMETRY = 'mcp_telemetry_logs';
+const TABLE_SNAPSHOTS = 'jstf_snapshots';
 async function supabaseRequest(method, path, body, headers) {
     if (!isSupabaseConfigured()) {
         return { ok: false, status: 0, error: 'Supabase not configured' };
@@ -59,7 +61,7 @@ async function supabaseRequest(method, path, body, headers) {
  * Insert a prediction row. Returns the row ID or null on failure.
  */
 export async function insertPrediction(row) {
-    const result = await supabaseRequest('POST', TABLE, row);
+    const result = await supabaseRequest('POST', TABLE_PREDICTIONS, row);
     if (!result.ok) {
         process.stderr.write(`[seshat] Prediction log failed: ${result.error}\n`);
         return null;
@@ -72,7 +74,7 @@ export async function insertPrediction(row) {
  */
 export async function updateActualBurn(predictionId, actual) {
     // First fetch the prediction to compute drift
-    const fetchResult = await supabaseRequest('GET', `${TABLE}?id=eq.${predictionId}&select=predicted_total,status`);
+    const fetchResult = await supabaseRequest('GET', `${TABLE_PREDICTIONS}?id=eq.${predictionId}&select=predicted_total,status`);
     if (!fetchResult.ok) {
         process.stderr.write(`[seshat] Fetch prediction failed: ${fetchResult.error}\n`);
         return null;
@@ -98,7 +100,7 @@ export async function updateActualBurn(predictionId, actual) {
         status: 'completed',
         ...(actual.notes ? { notes: actual.notes } : {}),
     };
-    const updateResult = await supabaseRequest('PATCH', `${TABLE}?id=eq.${predictionId}`, updateBody);
+    const updateResult = await supabaseRequest('PATCH', `${TABLE_PREDICTIONS}?id=eq.${predictionId}`, updateBody);
     if (!updateResult.ok) {
         process.stderr.write(`[seshat] Update actual burn failed: ${updateResult.error}\n`);
         return null;
@@ -109,16 +111,22 @@ export async function updateActualBurn(predictionId, actual) {
  * Abandon a prediction (task was cancelled or not completed).
  */
 export async function abandonPrediction(predictionId) {
-    const result = await supabaseRequest('PATCH', `${TABLE}?id=eq.${predictionId}&status=eq.predicted`, { status: 'abandoned' });
+    const result = await supabaseRequest('PATCH', `${TABLE_PREDICTIONS}?id=eq.${predictionId}&status=eq.predicted`, { status: 'abandoned' });
     return result.ok;
 }
 /**
  * List recent predictions for a project (for calibration analysis).
  */
-export async function listPredictions(project, limit = 20) {
-    const filter = project ? `&project=eq.${encodeURIComponent(project)}` : '';
-    const result = await supabaseRequest('GET', `${TABLE}?select=*${filter}&order=created_at.desc&limit=${limit}`);
-    if (!result.ok)
-        return [];
-    return result.data || [];
+export async function logTelemetry(log) {
+    const result = await supabaseRequest('POST', TABLE_TELEMETRY, log);
+    if (!result.ok) {
+        process.stderr.write(`[seshat] Telemetry log failed: ${result.error}\n`);
+    }
+}
+export async function insertJstfSnapshot(snapshot) {
+    const result = await supabaseRequest('POST', TABLE_SNAPSHOTS, snapshot);
+    if (!result.ok) {
+        process.stderr.write(`[seshat] JSTF snapshot failed: ${result.error}\n`);
+    }
+    return result.ok;
 }

package/dist/tools/diff.js

@@ -261,25 +261,8 @@ export async function diffBundle(args) {
     }
     return result;
 }
-// ─── Conflict Tier Classification ─────────────────────────────────
-const ZONE_1 = new Set(['edges', 'imports']); // Header / Dependencies
-const ZONE_2 = new Set(['struct', 'constraints', 'traits', 'ownership']); // Signature / Modifiers
-const ZONE_3 = new Set(['semantics', 'data', 'runtime']); // Logic / Implementation        
-function getZones(scopes) {
-    const zones = new Set();
-    for (const s of scopes) {
-        const lower = s.toLowerCase();
-        if (ZONE_1.has(lower))
-            zones.add(1);
-        if (ZONE_2.has(lower))
-            zones.add(2);
-        if (ZONE_3.has(lower))
-            zones.add(3);
-    }
-    return zones;
-}
 function classifyConflictTier(taskA, taskB) {
-    // Check symbol overlap
+    // Check symbol overlap → Tier 3 (MUST sequence)
     const sharedEntities = [];
     for (const id of taskA.entityIds) {
         if (taskB.entityIds.has(id)) {
@@ -287,27 +270,9 @@ function classifyConflictTier(taskA, taskB) {
         }
     }
     if (sharedEntities.length > 0) {
-        // Both touch same symbol. Check scopes to see if we can downgrade from Tier 4 (Sequential) to Tier 3 (Parallelizable Orthogonal)
-        if (taskA.dimensions.size > 0 && taskB.dimensions.size > 0) {
-            const zonesA = getZones(taskA.dimensions);
-            const zonesB = getZones(taskB.dimensions);
-            let spatialCollision = false;
-            for (const z of zonesA) {
-                if (zonesB.has(z))
-                    spatialCollision = true;
-            }
-            if (!spatialCollision) {
-                return {
-                    tier: 3,
-                    reason: `${sharedEntities.length} shared symbols, but orthogonal change scopes (Tier 3) — safe to parallelize`,
-                    sharedFiles: [],
-                    sharedEntities,
-                };
-            }
-        }
         return {
-            tier: 4,
-            reason: `${sharedEntities.length} shared symbols in same/unknown change scope (Tier 4) — MUST sequence to prevent merge conflict`,
+            tier: 3,
+            reason: `${sharedEntities.length} shared symbols — MUST sequence to maintain surgical splice integrity`,
             sharedFiles: [],
             sharedEntities,
         };
@@ -327,26 +292,27 @@ function classifyConflictTier(taskA, taskB) {
             sharedEntities: [],
         };
     }
+    // Same file, different symbols → Tier 2 (Safe via Surgical Splicer)
     return {
         tier: 2,
-        reason: `${sharedFiles.length} shared files but different symbols — safe to parallelize`,
+        reason: `${sharedFiles.length} shared files but different symbols — safe to parallelize via surgical splicing`,
         sharedFiles,
         sharedEntities: [],
     };
 }
 // ─── Execution Plan Builder ───────────────────────────────────────
 /**
- * Build execution plan from tier-4 conflict graph using connected components.
- * Tasks with no tier-4 edges to each other run in parallel.
- * Tasks in the same tier-4 component run sequentially.
+ * Build execution plan from tier-3 conflict graph using connected components.
+ * Tasks with no tier-3 edges to each other run in parallel.
+ * Tasks in the same tier-3 component run sequentially.
  */
-function buildExecutionPlan(taskIds, tier4Edges) {
-    // Build adjacency list for tier-4 conflicts
+function buildExecutionPlan(taskIds, tier3Edges) {
+    // Build adjacency list for tier-3 conflicts
     const adj = new Map();
     for (const id of taskIds) {
         adj.set(id, new Set());
     }
-    for (const [a, b] of tier4Edges) {
+    for (const [a, b] of tier3Edges) {
         adj.get(a)?.add(b);
         adj.get(b)?.add(a);
     }
@@ -454,7 +420,7 @@ export function conflictMatrix(args) {
     }
     // Pairwise comparison
     const matrix = [];
-    const tier4Edges = [];
+    const tier3Edges = [];
     for (let i = 0; i < resolvedTasks.length; i++) {
         for (let j = i + 1; j < resolvedTasks.length; j++) {
             const taskA = resolvedTasks[i];
@@ -471,14 +437,14 @@ export function conflictMatrix(args) {
             if (result.sharedEntities.length > 0)
                 entry.sharedEntities = result.sharedEntities;
             matrix.push(entry);
-            if (result.tier === 4) {
-                tier4Edges.push([taskA.id, taskB.id]);
+            if (result.tier === 3) {
+                tier3Edges.push([taskA.id, taskB.id]);
             }
         }
     }
     // Build execution plan
     const taskIds = resolvedTasks.map(t => t.id);
-    const executionPlan = buildExecutionPlan(taskIds, tier4Edges);
+    const executionPlan = buildExecutionPlan(taskIds, tier3Edges);
     const result = {
         taskCount: tasks.length,
         matrix,

package/dist/tools/functors.js

@@ -8,7 +8,7 @@
 import path from 'path';
 import { computeBlastRadius } from '../graph.js';
 import { getLoader, getGraph, validateProject, entityName, entityLayer, entitySummary, } from './index.js';
-import { isSupabaseConfigured, insertPrediction, updateActualBurn, abandonPrediction, listPredictions, } from '../supabase.js';
+import { isSupabaseConfigured, insertPrediction, updateActualBurn, abandonPrediction, } from '../supabase.js';
 // ─── Layer ordering for violation detection ──────────────────────
 const LAYER_ORDER = {
     route: 0,
@@ -782,48 +782,9 @@ export async function reportActualBurn(args) {
     const { action = 'complete' } = args;
     // List mode: show recent predictions for calibration analysis
     if (action === 'list') {
-        const rows = await listPredictions(args.project);
-        if (rows.length === 0) {
-            return { message: 'No predictions found.', predictions: [] };
-        }
-        const summary = rows.map((r) => ({
-            id: r.id,
-            project: r.project,
-            targets: r.target_entities,
-            predicted: r.predicted_total,
-            actual: r.actual_total_tokens,
-            drift: r.drift_ratio,
-            estimator: r.estimator_used,
-            status: r.status,
-            createdAt: r.created_at,
-        }));
-        // Compute aggregate calibration stats for completed predictions
-        const completed = rows.filter((r) => r.status === 'completed' && r.drift_ratio != null);
-        let calibration;
-        if (completed.length >= 3) {
-            const drifts = completed.map((r) => r.drift_ratio);
-            const meanDrift = drifts.reduce((a, b) => a + b, 0) / drifts.length;
-            const sortedDrifts = [...drifts].sort((a, b) => a - b);
-            const medianDrift = sortedDrifts[Math.floor(sortedDrifts.length / 2)];
-            const maxOvershoot = Math.max(...drifts);
-            const maxUndershoot = Math.min(...drifts);
-            calibration = {
-                completedSamples: completed.length,
-                meanDrift: Math.round(meanDrift * 1000) / 1000,
-                medianDrift: Math.round(medianDrift * 1000) / 1000,
-                maxOvershoot: Math.round(maxOvershoot * 1000) / 1000,
-                maxUndershoot: Math.round(maxUndershoot * 1000) / 1000,
-                _interpretation: meanDrift > 0.2
-                    ? 'Predictions underestimate — consider increasing iteration multiplier.'
-                    : meanDrift < -0.2
-                        ? 'Predictions overestimate — consider decreasing iteration multiplier.'
-                        : 'Predictions are well-calibrated (within 20% mean drift).',
-            };
-        }
         return {
-            total: rows.length,
-            predictions: summary,
-            ...(calibration ? { calibration } : {}),
+            message: 'List predictions has been migrated to the Ptah Dashboard.',
+            predictions: []
         };
     }
     // Complete or abandon requires prediction_id

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@papyruslabsai/seshat-mcp",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Semantic MCP server — exposes a codebase's structure, dependencies, and constraints as queryable tools",
   "type": "module",
   "bin": {