switchman-dev 0.1.1 → 0.1.3

package/src/mcp/server.js

@@ -11,6 +11,7 @@
  *   switchman_task_claim   — claim files for a task (conflict-safe)
  *   switchman_task_done    — mark a task complete + release file claims
  *   switchman_task_fail    — mark a task failed + release file claims
+ *   switchman_lease_heartbeat — refresh a lease heartbeat
  *   switchman_scan         — scan all worktrees for conflicts right now
  *   switchman_status       — full system overview (tasks, claims, worktrees)
  */
@@ -23,12 +24,15 @@ import { findRepoRoot } from '../core/git.js';
 import {
   openDb,
   createTask,
-  assignTask,
+  startTaskLease,
   completeTask,
   failTask,
   listTasks,
-  getTask,
   getNextPendingTask,
+  listLeases,
+  getActiveLeaseForTask,
+  heartbeatLease,
+  getStaleLeases,
   claimFiles,
   releaseFileClaims,
   getActiveFileClaims,
@@ -36,6 +40,8 @@ import {
   listWorktrees,
 } from '../core/db.js';
 import { scanAllWorktrees } from '../core/detector.js';
+import { gatewayAppendFile, gatewayMakeDirectory, gatewayMovePath, gatewayRemovePath, gatewayWriteFile, monitorWorktreesOnce } from '../core/enforcement.js';
+import { runAiMergeGate } from '../core/merge-gate.js';
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -95,7 +101,10 @@ Returns JSON:
       "description": string | null,
       "priority": number,    // 1-10, higher = more urgent
       "worktree": string,
-      "status": "in_progress"
+      "status": "in_progress",
+      "lease_id": string,    // Active lease/session ID for the task
+      "lease_status": "active",
+      "heartbeat_at": string
     } | null                 // null when queue is empty
   }
 
@@ -124,17 +133,27 @@ Examples:
         return toolOk(JSON.stringify({ task: null }), { task: null });
       }
 
-      const assigned = assignTask(db, task.id, worktree, agent ?? null);
-      db.close();
+      const lease = startTaskLease(db, task.id, worktree, agent ?? null);
 
-      if (!assigned) {
+      if (!lease) {
+        db.close();
         // Race condition: another agent grabbed it first — try again
         return toolOk(
           JSON.stringify({ task: null, message: 'Task was claimed by another agent. Call switchman_task_next again.' }),
         );
       }
 
-      const result = { task: { ...task, worktree, status: 'in_progress' } };
+      db.close();
+      const result = {
+        task: {
+          ...task,
+          worktree,
+          status: 'in_progress',
+          lease_id: lease.id,
+          lease_status: lease.status,
+          heartbeat_at: lease.heartbeat_at,
+        },
+      };
       return toolOk(JSON.stringify(result, null, 2), result);
     } catch (err) {
       return toolError(`${err.message}. Make sure switchman is initialised in this repo (run 'switchman init').`);
@@ -210,16 +229,20 @@ Args:
   - worktree (string): Your git worktree name
   - files (array of strings): File paths you plan to edit, relative to repo root (e.g. ["src/auth/login.js", "tests/auth.test.js"])
   - agent (string, optional): Agent identifier for logging
+  - lease_id (string, optional): Active lease ID returned by switchman_task_next
   - force (boolean, optional): If true, claim even if conflicts exist (default: false)
 
 Returns JSON:
   {
+    "lease_id": string,
     "claimed": string[],     // Files successfully claimed
     "conflicts": [           // Files already claimed by other worktrees
       {
         "file": string,
+        "claimed_by_task_id": string,
         "claimed_by_worktree": string,
-        "claimed_by_task": string
+        "claimed_by_task": string,
+        "claimed_by_lease_id": string | null
       }
     ],
     "safe_to_proceed": boolean   // true if no conflicts (or force=true)
@@ -234,6 +257,7 @@ Examples:
       worktree: z.string().min(1).describe('Your git worktree name'),
       files: z.array(z.string().min(1)).min(1).max(500).describe('File paths to claim, relative to repo root'),
       agent: z.string().optional().describe('Agent identifier for logging'),
+      lease_id: z.string().optional().describe('Optional lease ID returned by switchman_task_next'),
       force: z.boolean().default(false).describe('Claim even if conflicts exist (use with caution)'),
     }),
     annotations: {
@@ -243,9 +267,10 @@ Examples:
       openWorldHint: false,
     },
   },
-  async ({ task_id, worktree, files, agent, force }) => {
+  async ({ task_id, worktree, files, agent, lease_id, force }) => {
+    let db;
     try {
-      const { db } = getContext();
+      ({ db } = getContext());
 
       // Check for conflicts first
       const conflicts = checkFileConflicts(db, files, worktree);
@@ -256,8 +281,10 @@ Examples:
           claimed: [],
           conflicts: conflicts.map((c) => ({
             file: c.file,
+            claimed_by_task_id: c.claimedBy.task_id,
             claimed_by_worktree: c.claimedBy.worktree,
             claimed_by_task: c.claimedBy.task_title,
+            claimed_by_lease_id: c.claimedBy.lease_id ?? null,
           })),
           safe_to_proceed: false,
         };
@@ -268,15 +295,20 @@ Examples:
         );
       }
 
-      claimFiles(db, task_id, worktree, files, agent ?? null);
-      db.close();
+      const lease = claimFiles(db, task_id, worktree, files, agent ?? null);
+      if (lease_id && lease.id !== lease_id) {
+        return toolError(`Task ${task_id} is active under lease ${lease.id}, not ${lease_id}.`);
+      }
 
       const result = {
+        lease_id: lease.id,
         claimed: files,
         conflicts: conflicts.map((c) => ({
           file: c.file,
+          claimed_by_task_id: c.claimedBy.task_id,
           claimed_by_worktree: c.claimedBy.worktree,
           claimed_by_task: c.claimedBy.task_title,
+          claimed_by_lease_id: c.claimedBy.lease_id ?? null,
         })),
         safe_to_proceed: true,
       };
@@ -286,6 +318,275 @@ Examples:
       );
     } catch (err) {
       return toolError(err.message);
+    } finally {
+      db?.close();
+    }
+  },
+);
+
+// ── switchman_write_file ──────────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_write_file',
+  {
+    title: 'Write File Through Switchman',
+    description: `Replaces a file's contents through the Switchman write gateway.
+
+Use this instead of direct filesystem writes when the agent is running in managed mode. The target path must already be claimed by the active lease.
+
+Args:
+  - lease_id (string): Active lease ID returned by switchman_task_next
+  - path (string): Target file path, relative to repo root
+  - content (string): Full replacement content
+  - worktree (string, optional): Expected worktree name for extra validation
+
+Returns JSON:
+  {
+    "ok": boolean,
+    "file_path": string,
+    "lease_id": string,
+    "bytes_written": number
+  }`,
+    inputSchema: z.object({
+      lease_id: z.string().min(1).describe('Active lease ID returned by switchman_task_next'),
+      path: z.string().min(1).describe('Target file path relative to repo root'),
+      content: z.string().describe('Full replacement content'),
+      worktree: z.string().optional().describe('Optional worktree name for validation'),
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+    },
+  },
+  async ({ lease_id, path, content, worktree }) => {
+    try {
+      const { repoRoot, db } = getContext();
+      const result = gatewayWriteFile(db, repoRoot, {
+        leaseId: lease_id,
+        path,
+        content,
+        worktree: worktree ?? null,
+      });
+      db.close();
+
+      if (!result.ok) {
+        return toolError(`Write denied for ${result.file_path ?? path}: ${result.reason_code}.`);
+      }
+
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(err.message);
+    }
+  },
+);
+
+// ── switchman_remove_path ─────────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_remove_path',
+  {
+    title: 'Remove Path Through Switchman',
+    description: `Removes a file or directory through the Switchman write gateway.
+
+Use this instead of direct filesystem deletion when the agent is running in managed mode. The target path must already be claimed by the active lease.
+
+Args:
+  - lease_id (string): Active lease ID returned by switchman_task_next
+  - path (string): Target file or directory path, relative to repo root
+  - worktree (string, optional): Expected worktree name for extra validation
+
+Returns JSON:
+  {
+    "ok": boolean,
+    "file_path": string,
+    "lease_id": string,
+    "removed": true
+  }`,
+    inputSchema: z.object({
+      lease_id: z.string().min(1).describe('Active lease ID returned by switchman_task_next'),
+      path: z.string().min(1).describe('Target path relative to repo root'),
+      worktree: z.string().optional().describe('Optional worktree name for validation'),
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  async ({ lease_id, path, worktree }) => {
+    try {
+      const { repoRoot, db } = getContext();
+      const result = gatewayRemovePath(db, repoRoot, {
+        leaseId: lease_id,
+        path,
+        worktree: worktree ?? null,
+      });
+      db.close();
+
+      if (!result.ok) {
+        return toolError(`Remove denied for ${result.file_path ?? path}: ${result.reason_code}.`);
+      }
+
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(err.message);
+    }
+  },
+);
+
+// ── switchman_append_file ─────────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_append_file',
+  {
+    title: 'Append File Through Switchman',
+    description: `Appends content to a claimed file through the Switchman write gateway.`,
+    inputSchema: z.object({
+      lease_id: z.string().min(1).describe('Active lease ID returned by switchman_task_next'),
+      path: z.string().min(1).describe('Target file path relative to repo root'),
+      content: z.string().describe('Content to append'),
+      worktree: z.string().optional().describe('Optional worktree name for validation'),
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+    },
+  },
+  async ({ lease_id, path, content, worktree }) => {
+    try {
+      const { repoRoot, db } = getContext();
+      const result = gatewayAppendFile(db, repoRoot, {
+        leaseId: lease_id,
+        path,
+        content,
+        worktree: worktree ?? null,
+      });
+      db.close();
+
+      if (!result.ok) {
+        return toolError(`Append denied for ${result.file_path ?? path}: ${result.reason_code}.`);
+      }
+
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(err.message);
+    }
+  },
+);
+
+// ── switchman_move_path ───────────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_move_path',
+  {
+    title: 'Move Path Through Switchman',
+    description: `Moves a claimed file to another claimed path through the Switchman write gateway.`,
+    inputSchema: z.object({
+      lease_id: z.string().min(1).describe('Active lease ID returned by switchman_task_next'),
+      source_path: z.string().min(1).describe('Source file path relative to repo root'),
+      destination_path: z.string().min(1).describe('Destination file path relative to repo root'),
+      worktree: z.string().optional().describe('Optional worktree name for validation'),
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false,
+    },
+  },
+  async ({ lease_id, source_path, destination_path, worktree }) => {
+    try {
+      const { repoRoot, db } = getContext();
+      const result = gatewayMovePath(db, repoRoot, {
+        leaseId: lease_id,
+        sourcePath: source_path,
+        destinationPath: destination_path,
+        worktree: worktree ?? null,
+      });
+      db.close();
+
+      if (!result.ok) {
+        return toolError(`Move denied for ${result.file_path ?? destination_path}: ${result.reason_code}.`);
+      }
+
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(err.message);
+    }
+  },
+);
+
+// ── switchman_make_directory ──────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_make_directory',
+  {
+    title: 'Create Directory Through Switchman',
+    description: `Creates a directory through the Switchman write gateway when it is part of a claimed destination path.`,
+    inputSchema: z.object({
+      lease_id: z.string().min(1).describe('Active lease ID returned by switchman_task_next'),
+      path: z.string().min(1).describe('Directory path relative to repo root'),
+      worktree: z.string().optional().describe('Optional worktree name for validation'),
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  async ({ lease_id, path, worktree }) => {
+    try {
+      const { repoRoot, db } = getContext();
+      const result = gatewayMakeDirectory(db, repoRoot, {
+        leaseId: lease_id,
+        path,
+        worktree: worktree ?? null,
+      });
+      db.close();
+
+      if (!result.ok) {
+        return toolError(`Mkdir denied for ${result.file_path ?? path}: ${result.reason_code}.`);
+      }
+
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(err.message);
+    }
+  },
+);
+
+// ── switchman_monitor_once ────────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_monitor_once',
+  {
+    title: 'Observe Runtime File Changes Once',
+    description: `Runs one filesystem monitoring pass across all registered worktrees.
+
+This compares the current worktree file state against the previous Switchman snapshot, logs observed mutations, and classifies them as allowed or denied based on the active lease and claims.`,
+    inputSchema: z.object({}),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false,
+    },
+  },
+  async () => {
+    try {
+      const { repoRoot, db } = getContext();
+      const worktrees = listWorktrees(db);
+      const result = monitorWorktreesOnce(db, repoRoot, worktrees);
+      db.close();
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(err.message);
     }
   },
 );
@@ -302,15 +603,18 @@ Call this when you have finished your implementation and committed your changes.
 
 Args:
   - task_id (string): The task ID to complete
+  - lease_id (string, optional): Active lease ID returned by switchman_task_next
 
 Returns JSON:
   {
     "task_id": string,
+    "lease_id": string | null,
     "status": "done",
     "files_released": true
   }`,
     inputSchema: z.object({
       task_id: z.string().min(1).describe('The task ID to mark complete'),
+      lease_id: z.string().optional().describe('Optional lease ID returned by switchman_task_next'),
     }),
     annotations: {
       readOnlyHint: false,
@@ -319,14 +623,19 @@ Returns JSON:
       openWorldHint: false,
     },
   },
-  async ({ task_id }) => {
+  async ({ task_id, lease_id }) => {
     try {
       const { db } = getContext();
+      const activeLease = getActiveLeaseForTask(db, task_id);
+      if (lease_id && activeLease && activeLease.id !== lease_id) {
+        db.close();
+        return toolError(`Task ${task_id} is active under lease ${activeLease.id}, not ${lease_id}.`);
+      }
       completeTask(db, task_id);
       releaseFileClaims(db, task_id);
       db.close();
 
-      const result = { task_id, status: 'done', files_released: true };
+      const result = { task_id, lease_id: activeLease?.id ?? lease_id ?? null, status: 'done', files_released: true };
       return toolOk(JSON.stringify(result, null, 2), result);
     } catch (err) {
       return toolError(err.message);
@@ -346,17 +655,20 @@ Call this if you cannot complete the task — the task will be visible in the qu
 
 Args:
   - task_id (string): The task ID to mark as failed
+  - lease_id (string, optional): Active lease ID returned by switchman_task_next
   - reason (string): Brief explanation of why the task failed
 
 Returns JSON:
   {
     "task_id": string,
+    "lease_id": string | null,
     "status": "failed",
     "reason": string,
     "files_released": true
   }`,
     inputSchema: z.object({
       task_id: z.string().min(1).describe('The task ID to mark as failed'),
+      lease_id: z.string().optional().describe('Optional lease ID returned by switchman_task_next'),
       reason: z.string().min(1).max(500).describe('Brief explanation of why the task failed'),
     }),
     annotations: {
@@ -366,14 +678,74 @@ Returns JSON:
       openWorldHint: false,
     },
   },
-  async ({ task_id, reason }) => {
+  async ({ task_id, lease_id, reason }) => {
     try {
       const { db } = getContext();
+      const activeLease = getActiveLeaseForTask(db, task_id);
+      if (lease_id && activeLease && activeLease.id !== lease_id) {
+        db.close();
+        return toolError(`Task ${task_id} is active under lease ${activeLease.id}, not ${lease_id}.`);
+      }
       failTask(db, task_id, reason);
       releaseFileClaims(db, task_id);
       db.close();
 
-      const result = { task_id, status: 'failed', reason, files_released: true };
+      const result = { task_id, lease_id: activeLease?.id ?? lease_id ?? null, status: 'failed', reason, files_released: true };
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(err.message);
+    }
+  },
+);
+
+// ── switchman_lease_heartbeat ─────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_lease_heartbeat',
+  {
+    title: 'Refresh Lease Heartbeat',
+    description: `Refreshes the heartbeat timestamp for an active lease.
+
+Call this periodically while an agent is still working on a task so stale-session reaping does not recycle the task prematurely.
+
+Args:
+  - lease_id (string): Active lease ID returned by switchman_task_next
+  - agent (string, optional): Agent identifier to attach to the refreshed lease
+
+Returns JSON:
+  {
+    "lease_id": string,
+    "task_id": string,
+    "worktree": string,
+    "heartbeat_at": string
+  }`,
+    inputSchema: z.object({
+      lease_id: z.string().min(1).describe('Active lease ID returned by switchman_task_next'),
+      agent: z.string().optional().describe('Agent identifier for logging'),
+    }),
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  async ({ lease_id, agent }) => {
+    try {
+      const { db } = getContext();
+      const lease = heartbeatLease(db, lease_id, agent ?? null);
+      db.close();
+
+      if (!lease) {
+        return toolError(`Lease ${lease_id} was not found or is no longer active.`);
+      }
+
+      const result = {
+        lease_id: lease.id,
+        task_id: lease.task_id,
+        worktree: lease.worktree,
+        heartbeat_at: lease.heartbeat_at,
+      };
       return toolOk(JSON.stringify(result, null, 2), result);
     } catch (err) {
       return toolError(err.message);
@@ -439,8 +811,10 @@ Examples:
           name: wt.name,
           branch: wt.branch ?? 'unknown',
           changed_files: (report.fileMap?.[wt.name] ?? []).length,
+          compliance_state: report.worktreeCompliance?.find((entry) => entry.worktree === wt.name)?.compliance_state ?? wt.compliance_state ?? 'observed',
         })),
         file_conflicts: report.fileConflicts,
+        unclaimed_changes: report.unclaimedChanges,
         branch_conflicts: report.conflicts.map((c) => ({
           type: c.type,
           worktree_a: c.worktreeA,
@@ -449,7 +823,8 @@ Examples:
           branch_b: c.branchB,
           conflicting_files: c.conflictingFiles,
         })),
-        safe_to_proceed: report.conflicts.length === 0 && report.fileConflicts.length === 0,
+        compliance_summary: report.complianceSummary,
+        safe_to_proceed: report.conflicts.length === 0 && report.fileConflicts.length === 0 && report.unclaimedChanges.length === 0,
         summary: report.summary,
       };
       return toolOk(JSON.stringify(result, null, 2), result);
@@ -459,6 +834,52 @@ Examples:
   },
 );
 
+// ── switchman_merge_gate ──────────────────────────────────────────────────────
+
+server.registerTool(
+  'switchman_merge_gate',
+  {
+    title: 'Run AI Merge Gate',
+    description: `Evaluates semantic merge risk across active worktrees using Switchman's local change graph.
+
+This is an AI-style merge gate implemented as a deterministic local reviewer. It combines:
+  1. Existing enforcement signals
+  2. Exact file overlaps and git merge conflicts
+  3. Shared subsystem overlap
+  4. High-risk areas like auth, schema, config, and API changes
+  5. Missing-test signals for source-heavy worktrees
+
+Args:
+  - (none required)
+
+Returns JSON:
+  {
+    "ok": boolean,
+    "status": "pass" | "warn" | "blocked",
+    "summary": string,
+    "worktrees": [{ "worktree": string, "score": number, "findings": string[] }],
+    "pairs": [{ "worktree_a": string, "worktree_b": string, "status": string, "score": number, "reasons": string[] }]
+  }`,
+    inputSchema: z.object({}),
+    annotations: {
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+    },
+  },
+  async () => {
+    try {
+      const { repoRoot, db } = getContext();
+      const result = await runAiMergeGate(db, repoRoot);
+      db.close();
+      return toolOk(JSON.stringify(result, null, 2), result);
+    } catch (err) {
+      return toolError(`AI merge gate failed: ${err.message}. Ensure switchman is initialised ('switchman init').`);
+    }
+  },
+);
+
 // ── switchman_status ───────────────────────────────────────────────────────────
 
 server.registerTool(
@@ -479,13 +900,17 @@ Returns JSON:
       "in_progress": number,
       "done": number,
       "failed": number,
-      "active": [{ "id": string, "title": string, "worktree": string, "priority": number }]
+      "active": [{ "id": string, "title": string, "worktree": string, "priority": number, "lease_id": string | null }]
     },
     "file_claims": {
       "total_active": number,
-      "by_worktree": { [worktree: string]: string[] }   // worktree -> files
+      "by_worktree": { [worktree: string]: { "file_path": string, "task_id": string, "lease_id": string | null }[] }
     },
-    "worktrees": [{ "name": string, "branch": string, "agent": string | null, "status": string }],
+    "leases": {
+      "active": [{ "id": string, "task_id": string, "worktree": string, "agent": string | null, "heartbeat_at": string }],
+      "stale": [{ "id": string, "task_id": string, "worktree": string, "heartbeat_at": string }]
+    },
+    "worktrees": [{ "name": string, "branch": string, "agent": string | null, "status": string, "active_lease_id": string | null }],
     "repo_root": string
   }`,
     inputSchema: z.object({}),
@@ -503,14 +928,27 @@ Returns JSON:
       const tasks = listTasks(db);
       const claims = getActiveFileClaims(db);
       const worktrees = listWorktrees(db);
+      const leases = listLeases(db);
+      const staleLeases = getStaleLeases(db);
       db.close();
 
       const byWorktree = {};
       for (const c of claims) {
         if (!byWorktree[c.worktree]) byWorktree[c.worktree] = [];
-        byWorktree[c.worktree].push(c.file_path);
+        byWorktree[c.worktree].push({
+          file_path: c.file_path,
+          task_id: c.task_id,
+          lease_id: c.lease_id ?? null,
+        });
       }
 
+      const activeLeaseByTask = new Map(
+        leases.filter((lease) => lease.status === 'active').map((lease) => [lease.task_id, lease]),
+      );
+      const activeLeaseByWorktree = new Map(
+        leases.filter((lease) => lease.status === 'active').map((lease) => [lease.worktree, lease]),
+      );
+
       const result = {
         tasks: {
           pending: tasks.filter((t) => t.status === 'pending').length,
@@ -519,17 +957,47 @@ Returns JSON:
           failed: tasks.filter((t) => t.status === 'failed').length,
           active: tasks
             .filter((t) => t.status === 'in_progress')
-            .map((t) => ({ id: t.id, title: t.title, worktree: t.worktree, priority: t.priority })),
+            .map((t) => ({
+              id: t.id,
+              title: t.title,
+              worktree: t.worktree,
+              priority: t.priority,
+              lease_id: activeLeaseByTask.get(t.id)?.id ?? null,
+            })),
         },
         file_claims: {
           total_active: claims.length,
           by_worktree: byWorktree,
+          claims: claims.map((claim) => ({
+            file_path: claim.file_path,
+            worktree: claim.worktree,
+            task_id: claim.task_id,
+            lease_id: claim.lease_id ?? null,
+          })),
+        },
+        leases: {
+          active: leases.filter((lease) => lease.status === 'active').map((lease) => ({
+            id: lease.id,
+            task_id: lease.task_id,
+            worktree: lease.worktree,
+            agent: lease.agent ?? null,
+            heartbeat_at: lease.heartbeat_at,
+          })),
+          stale: staleLeases.map((lease) => ({
+            id: lease.id,
+            task_id: lease.task_id,
+            worktree: lease.worktree,
+            heartbeat_at: lease.heartbeat_at,
+          })),
         },
         worktrees: worktrees.map((wt) => ({
           name: wt.name,
           branch: wt.branch,
           agent: wt.agent ?? null,
           status: wt.status,
+          enforcement_mode: wt.enforcement_mode ?? 'observed',
+          compliance_state: wt.compliance_state ?? 'observed',
+          active_lease_id: activeLeaseByWorktree.get(wt.name)?.id ?? null,
         })),
         repo_root: repoRoot,
       };
@@ -552,4 +1020,4 @@ async function main() {
 main().catch((err) => {
   process.stderr.write(`switchman MCP server fatal error: ${err.message}\n`);
   process.exit(1);
-});
+});