mcp-coordinator 0.4.0 → 0.6.0

package/dist/src/metrics.d.ts

@@ -42,6 +42,11 @@ export declare class Metrics {
     readonly threadsResolving: Gauge<string>;
     readonly mqttListenersActive: Gauge<string>;
     readonly sseClientsActive: Gauge<string>;
+    readonly workingFilesActive: Gauge<string>;
+    readonly gitCochangePairs: Gauge<string>;
+    readonly workingFilesStarts: Counter<"result">;
+    readonly treeSitterParseFailures: Counter<string>;
+    readonly gitCochangeBuilds: Counter<"outcome">;
     constructor(opts?: MetricsOptions);
     recordAnnounce(result: AnnounceResult): void;
     recordThreadResolved(type: ResolutionType): void;

package/dist/src/metrics.js

@@ -14,6 +14,12 @@ export class Metrics {
     threadsResolving;
     mqttListenersActive;
     sseClientsActive;
+    workingFilesActive;
+    gitCochangePairs;
+    // v0.6 counters
+    workingFilesStarts;
+    treeSitterParseFailures;
+    gitCochangeBuilds;
     constructor(opts = {}) {
         this.registry = new Registry();
         if (opts.collectDefault !== false) {
@@ -72,6 +78,33 @@ export class Metrics {
             help: "Current number of connected SSE clients",
             registers: [this.registry],
         });
+        this.workingFilesActive = new Gauge({
+            name: "mcp_coordinator_working_files_active",
+            help: "Current working_files row count",
+            registers: [this.registry],
+        });
+        this.workingFilesStarts = new Counter({
+            name: "mcp_coordinator_working_files_starts_total",
+            help: "Total working_files start calls",
+            labelNames: ["result"],
+            registers: [this.registry],
+        });
+        this.treeSitterParseFailures = new Counter({
+            name: "mcp_coordinator_tree_sitter_parse_failures_total",
+            help: "Tree-sitter parse failures",
+            registers: [this.registry],
+        });
+        this.gitCochangeBuilds = new Counter({
+            name: "mcp_coordinator_git_cochange_builds_total",
+            help: "git_cochange build attempts",
+            labelNames: ["outcome"],
+            registers: [this.registry],
+        });
+        this.gitCochangePairs = new Gauge({
+            name: "mcp_coordinator_git_cochange_pairs_total",
+            help: "Current git_cochange row count",
+            registers: [this.registry],
+        });
     }
     // ── Counter helpers (named methods make hook points obvious) ──
     recordAnnounce(result) {

package/dist/src/path-normalize.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Normalize a file path for matching/correctness — NOT security.
+ *
+ * Returns POSIX (forward slash), repo-relative when repoRoot is provided,
+ * lower-cased when the path is Windows-style (drive letter prefix in repoRoot
+ * or input, or backslash in input). Collapses ./ and .. segments via
+ * path.posix.normalize.
+ *
+ * The lowercase pass is anchored to path SHAPE rather than `process.platform`
+ * so a Linux coordinator processing paths from a Windows agent (or a CI run
+ * exercising Windows-shaped fixtures) still produces consistent canonical
+ * forms.
+ *
+ * Throws when an absolute path falls outside repoRoot. Security path
+ * traversal checks are separate (see path-guard.ts:safeJoinUnderRoot).
+ */
+export declare function normalizePath(repoRoot: string | null, input: string): string;

package/dist/src/path-normalize.js

@@ -0,0 +1,38 @@
+import path from "path";
+/**
+ * Normalize a file path for matching/correctness — NOT security.
+ *
+ * Returns POSIX (forward slash), repo-relative when repoRoot is provided,
+ * lower-cased when the path is Windows-style (drive letter prefix in repoRoot
+ * or input, or backslash in input). Collapses ./ and .. segments via
+ * path.posix.normalize.
+ *
+ * The lowercase pass is anchored to path SHAPE rather than `process.platform`
+ * so a Linux coordinator processing paths from a Windows agent (or a CI run
+ * exercising Windows-shaped fixtures) still produces consistent canonical
+ * forms.
+ *
+ * Throws when an absolute path falls outside repoRoot. Security path
+ * traversal checks are separate (see path-guard.ts:safeJoinUnderRoot).
+ */
+export function normalizePath(repoRoot, input) {
+    const isWindowsStyle = (repoRoot != null && (/^[a-zA-Z]:/.test(repoRoot) || repoRoot.includes("\\"))) ||
+        /^[a-zA-Z]:/.test(input) ||
+        input.includes("\\");
+    let p = input.replace(/\\/g, "/");
+    if (repoRoot) {
+        const root = repoRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+        if (path.isAbsolute(input) || /^[a-zA-Z]:/.test(input)) {
+            const lowerP = isWindowsStyle ? p.toLowerCase() : p;
+            const lowerRoot = isWindowsStyle ? root.toLowerCase() : root;
+            if (!lowerP.startsWith(lowerRoot + "/") && lowerP !== lowerRoot) {
+                throw new Error(`path is outside repoRoot: ${input}`);
+            }
+            p = p.slice(root.length).replace(/^\/+/, "");
+        }
+    }
+    p = path.posix.normalize(p).replace(/^\.\//, "");
+    if (isWindowsStyle)
+        p = p.toLowerCase();
+    return p;
+}

package/dist/src/serve-http.js

@@ -17,6 +17,8 @@ import { createLogger } from "./logger.js";
 import { initAuth, authenticateRequest, createToken, refreshToken, revokeAgent, setAuthLogger, verifyToken } from "./auth.js";
 import { safeJoinUnderRoot } from "./path-guard.js";
 import { handleRest as handleRestExt } from "./http/handle-rest.js";
+import { handleLivez, handleReadyz, handleHealth } from "./http/handle-health.js";
+import { serveMetrics } from "./metrics.js";
 import { parseBody as parseBodyShared, json as jsonShared } from "./http/utils.js";
 import { getVersion } from "../cli/version.js";
 const VERSION = getVersion();
@@ -83,7 +85,15 @@ async function handleRest(req, res) {
 }
 async function handleAuth(req, res) {
     const url = req.url || "";
-    const body = await parseBody(req);
+    let body;
+    try {
+        body = await parseBody(req);
+    }
+    catch (err) {
+        const e = err;
+        json(res, { error: e.message || "Invalid request" }, e.statusCode || 400);
+        return;
+    }
     if (url === "/api/auth/register" && req.method === "POST") {
         const { agent_name, registration_secret } = body;
         if (!agent_name || !registration_secret) {
@@ -184,6 +194,8 @@ function handleSse(req, res) {
         Connection: "keep-alive",
         "Access-Control-Allow-Origin": "*",
     });
+    services.metrics.incSseClients();
+    services.metrics.recordHttpRequest("/api/events", 200);
     // Use Last-Event-ID for resumption, otherwise send last 50
     const lastEventId = parseInt(req.headers["last-event-id"] || "0", 10);
     const events = lastEventId > 0
@@ -217,6 +229,7 @@ function handleSse(req, res) {
         // fires between close and unsubscribe can't write to a dead socket.
         clearInterval(heartbeat);
         unsubscribe();
+        services.metrics.decSseClients();
     });
 }
 export async function startServer(opts) {
@@ -303,8 +316,21 @@ export async function startServer(opts) {
                 }
                 return;
             }
+            else if (url === "/livez") {
+                handleLivez(req, res);
+                services.metrics.recordHttpRequest("/livez", 200);
+            }
+            else if (url === "/readyz") {
+                handleReadyz(req, res, services);
+                services.metrics.recordHttpRequest("/readyz", res.statusCode || 0);
+            }
             else if (url === "/health") {
-                json(res, { status: "ok", version: VERSION });
+                handleHealth(req, res);
+                services.metrics.recordHttpRequest("/health", 200);
+            }
+            else if (url === "/metrics" && req.method === "GET") {
+                await serveMetrics(req, res, services, services.metrics);
+                services.metrics.recordHttpRequest("/metrics", 200);
             }
             else if (url === "/api/events" && req.method === "GET") {
                 handleSse(req, res);
@@ -361,15 +387,18 @@ export async function startServer(opts) {
                     const authResult = await authenticateRequest(req);
                     if (!authResult.ok) {
                         authLog.warn({ reason: authResult.error, url, ip: req.socket.remoteAddress }, "Auth rejected");
+                        services.metrics.recordAuthRejected();
                         json(res, { error: authResult.error }, authResult.status);
                         return;
                     }
                 }
                 if (url.startsWith("/api/") && (req.method === "POST" || req.method === "GET")) {
                     await handleRest(req, res);
+                    services.metrics.recordHttpRequest((url.split("?")[0] || ""), res.statusCode || 0);
                 }
                 else {
                     json(res, { error: "not found" }, 404);
+                    services.metrics.recordHttpRequest((url.split("?")[0] || ""), 404);
                 }
             }
         }
@@ -418,6 +447,10 @@ export async function startServer(opts) {
     services.mqttBridge.onOffline((agentId) => {
         services.registry.setOffline(agentId);
         services.consultation.handleAgentDeparture(agentId);
+        // Clear in-flight working_files AFTER consultation cleanup so any future
+        // consultation logic that might inspect working_files state for this agent
+        // sees the pre-cleanup view.
+        services.workingFiles.clearForAgent(agentId);
         services.sseEmitter.emit("agent_offline", { agent_id: agentId });
     });
     // Wait for the HTTP server to be actually listening before resolving the
@@ -483,6 +516,12 @@ export async function startServer(opts) {
         catch (err) {
             log.warn({ err }, "Error stopping timeout sweeper");
         }
+        try {
+            services.workingFiles.stopSweeper();
+        }
+        catch (err) {
+            log.warn({ err }, "Error stopping working-files sweeper");
+        }
         try {
             const { closeDb } = await import("./database.js");
             closeDb?.();

package/dist/src/server-setup.d.ts

@@ -11,7 +11,10 @@ import { SseEmitter } from "./sse-emitter.js";
 import { MqttBridge } from "./mqtt-bridge.js";
 import { AgentActivityTracker } from "./agent-activity.js";
 import { QuotaCache } from "./quota/quota-cache.js";
+import { WorkingFilesTracker } from "./working-files-tracker.js";
 import { Metrics } from "./metrics.js";
+import { TreeSitterExtractor } from "./tree-sitter-extractor.js";
+import { GitCochangeBuilder } from "./git-cochange-builder.js";
 import type { CoordinatorConfig } from "./types.js";
 import { type Logger } from "./logger.js";
 export interface CoordinatorServices {
@@ -23,12 +26,15 @@ export interface CoordinatorServices {
     depMap: DependencyMapper;
     fileTracker: FileTracker;
     impactScorer: ImpactScorer;
+    workingFiles: WorkingFilesTracker;
     introspection: IntrospectionManager;
     contextProvider: SummaryContextProvider;
     sseEmitter: SseEmitter;
     mqttBridge: MqttBridge;
     quotaCache: QuotaCache;
     metrics: Metrics;
+    treeSitter: TreeSitterExtractor;
+    gitCochange: GitCochangeBuilder | null;
 }
 /** Create shared services (once at startup). */
 export declare function createServices(config: CoordinatorConfig): CoordinatorServices;

package/dist/src/server-setup.js

@@ -18,7 +18,10 @@ import { SseEmitter } from "./sse-emitter.js";
 import { MqttBridge } from "./mqtt-bridge.js";
 import { AgentActivityTracker } from "./agent-activity.js";
 import { QuotaCache } from "./quota/quota-cache.js";
+import { WorkingFilesTracker } from "./working-files-tracker.js";
 import { Metrics } from "./metrics.js";
+import { TreeSitterExtractor } from "./tree-sitter-extractor.js";
+import { GitCochangeBuilder } from "./git-cochange-builder.js";
 import { createLogger } from "./logger.js";
 import { getVersion } from "../cli/version.js";
 const VERSION = getVersion();
@@ -26,18 +29,35 @@ const VERSION = getVersion();
 export function createServices(config) {
     initDatabase(config.dataDir);
     const logger = createLogger();
+    const metrics = new Metrics();
     const registry = new AgentRegistry();
     const activityTracker = new AgentActivityTracker(registry);
     const consultation = new Consultation(logger.child({ component: "consultation" }));
     const depMap = new DependencyMapper();
     const fileTracker = new FileTracker();
-    const impactScorer = new ImpactScorer(registry, fileTracker, consultation);
+    const workingFiles = new WorkingFilesTracker(logger.child({ component: "working-files" }), metrics);
+    workingFiles.startSweeper(parseInt(process.env.COORDINATOR_WORKING_FILES_SWEEP_INTERVAL_MS || "60000", 10));
+    const impactScorer = new ImpactScorer(registry, fileTracker, consultation, workingFiles);
     const introspection = new IntrospectionManager();
     const conflictDetector = new ConflictDetector(consultation, depMap, fileTracker, logger.child({ component: "conflict" }));
     const contextProvider = new SummaryContextProvider(registry, consultation, fileTracker);
     const sseEmitter = new SseEmitter();
     const mqttBridge = new MqttBridge(logger.child({ component: "mqtt" }));
-    const metrics = new Metrics();
+    const treeSitter = new TreeSitterExtractor(metrics);
+    treeSitter.load().catch(() => { });
+    const repoRoot = process.env.COORDINATOR_REPO_ROOT;
+    const gitCochange = repoRoot
+        ? new GitCochangeBuilder({
+            repoRoot,
+            logger: logger.child({ component: "gitcc" }),
+            metrics,
+            sinceDays: parseInt(process.env.COORDINATOR_LAYER4_SINCE_DAYS || "7", 10),
+            maxCount: parseInt(process.env.COORDINATOR_LAYER4_MAX_COMMITS || "2000", 10),
+            refreshMs: parseInt(process.env.COORDINATOR_LAYER4_REFRESH_INTERVAL_MS || "1800000", 10),
+            retryMs: parseInt(process.env.COORDINATOR_LAYER4_RETRY_MS || "300000", 10),
+        })
+        : null;
+    gitCochange?.startScheduler();
     // Quota cache — macOS-only for now, Linux/Windows stubs return 503 via the
     // /api/quota handler so raids keep running without a quota guardrail there.
     // onRefresh fans the new data out to dashboard (SSE) + any live listener (MQTT)
@@ -88,7 +108,7 @@ export function createServices(config) {
     });
     return {
         logger, registry, activityTracker, consultation, conflictDetector,
-        depMap, fileTracker, impactScorer, introspection, contextProvider, sseEmitter, mqttBridge, quotaCache, metrics,
+        depMap, fileTracker, impactScorer, workingFiles, introspection, contextProvider, sseEmitter, mqttBridge, quotaCache, metrics, treeSitter, gitCochange,
     };
 }
 /** Create a new McpServer bound to the shared services (one per MCP session). */

package/dist/src/tools/consultation-tools.js

@@ -30,7 +30,9 @@ export function registerConsultationTools(server, services, mcpLog) {
         exports_affected: z.array(z.string()).optional(),
         keep_open: z.boolean().optional().describe("Keep thread open even if no agents are concerned (for manual coordination like games or debates)"),
         assigned_to: z.string().optional().describe("Directed-dispatch: only this agent_id will be allowed to claim the thread. Use for lead→worker handoffs in maitre/chaine/relais presets. Implies keep_open=true."),
-    }, async ({ agent_id, subject, plan, target_modules, target_files, depends_on_files, exports_affected, keep_open, assigned_to }) => {
+        target_symbols: z.array(z.string().max(256)).max(200).optional()
+            .describe("Qualified symbol names you intend to touch (e.g. 'UserService.getById'). Used by Layer 0.5 to annotate same-file overlaps."),
+    }, async ({ agent_id, subject, plan, target_modules, target_files, depends_on_files, exports_affected, keep_open, assigned_to, target_symbols }) => {
         mcpLog.info({ tool: "announce_work", agent_id, subject, target_modules, target_files, assigned_to }, "Tool called");
         const conflicts = conflictDetector.detect({ agent_id, target_modules, target_files });
         const thread = consultation.announceWork({
@@ -41,7 +43,7 @@ export function registerConsultationTools(server, services, mcpLog) {
                 .run(JSON.stringify(conflicts), thread.id);
         }
         const { updated, categorized, respondents, planQuality } = runCommonAnnounceFlow(services, thread.id, {
-            agent_id, subject, plan, target_modules, target_files, depends_on_files, exports_affected, keep_open,
+            agent_id, subject, plan, target_modules, target_files, depends_on_files, exports_affected, keep_open, target_symbols,
         });
         sseEmitter.emit("thread_opened", {
             thread_id: thread.id, initiator: agent_id, subject, target_modules, conflicts,

package/dist/src/tree-sitter-extractor.d.ts

@@ -0,0 +1,36 @@
+import type { Metrics } from "./metrics.js";
+/**
+ * Tree-sitter symbol extractor.
+ *
+ * Loads grammars asynchronously at boot. extract() runs synchronously per call
+ * so it slots into the existing synchronous file_activity ingest path.
+ *
+ * Naming table per language documented in the v0.6 spec:
+ * - top-level fn / arrow assigned to const → `name`
+ * - class member  → `Class.method`
+ * - anonymous default export → `<file_basename>:default`
+ * - re-exports, anonymous IIFE → not emitted
+ */
+export declare class TreeSitterExtractor {
+    private grammars;
+    private ready;
+    private grammarsLoaded;
+    private totalGrammars;
+    private metrics?;
+    constructor(metrics?: Metrics);
+    load(): Promise<void>;
+    status(): {
+        ok: boolean;
+        grammars_loaded: number;
+        total_grammars: number;
+        optional: true;
+    };
+    /**
+     * Extract qualified symbol names from `content`. Returns null on parse
+     * failure, unsupported extension, or grammar not loaded.
+     * Caps output at 200 entries (per spec).
+     */
+    extract(filePath: string, content: string, _changedRanges: Array<[number, number]> | null): string[] | null;
+    private extToKey;
+    private walk;
+}