switchman-dev 0.1.7 → 0.1.8

package/src/core/ci.js

@@ -273,7 +273,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 22
 
       - name: Install Switchman
         run: npm install -g switchman-dev

package/src/core/db.js

@@ -14,7 +14,7 @@ const SWITCHMAN_DIR = '.switchman';
 const DB_FILE = 'switchman.db';
 const AUDIT_KEY_FILE = 'audit.key';
 const MIGRATION_STATE_FILE = 'migration-state.json';
-const CURRENT_SCHEMA_VERSION = 5;
+const CURRENT_SCHEMA_VERSION = 6;
 
 // How long (ms) a writer will wait for a lock before giving up.
 // 5 seconds is generous for a CLI tool with 3-10 concurrent agents.
@@ -22,6 +22,7 @@ const BUSY_TIMEOUT_MS = 10000;
 const CLAIM_RETRY_DELAY_MS = 200;
 const CLAIM_RETRY_ATTEMPTS = 20;
 export const DEFAULT_STALE_LEASE_MINUTES = 15;
+const DB_PRUNE_RETENTION_DAYS = 30;
 
 function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
@@ -524,6 +525,24 @@ function applySchemaVersion5(db) {
   `);
 }
 
+function applySchemaVersion6(db) {
+  db.exec(`
+    UPDATE file_claims
+    SET released_at = COALESCE(released_at, datetime('now'))
+    WHERE released_at IS NULL
+      AND id NOT IN (
+        SELECT MIN(id)
+        FROM file_claims
+        WHERE released_at IS NULL
+        GROUP BY file_path
+      );
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_file_claims_active_path
+      ON file_claims(file_path)
+      WHERE released_at IS NULL;
+  `);
+}
+
 function ensureSchemaMigrated(db) {
   const repoRoot = db.__switchmanRepoRoot;
   if (!repoRoot) {
@@ -572,6 +591,9 @@ function ensureSchemaMigrated(db) {
       if (currentVersion < 5) {
         applySchemaVersion5(db);
       }
+      if (currentVersion < 6) {
+        applySchemaVersion6(db);
+      }
       setSchemaVersion(db, CURRENT_SCHEMA_VERSION);
     });
     clearMigrationState(repoRoot);
@@ -826,8 +848,8 @@ function reserveLeaseScopesTx(db, lease) {
   const conflicts = findScopeReservationConflicts(reservations, activeReservations);
   if (conflicts.length > 0) {
     const summary = conflicts[0].type === 'subsystem'
-      ? `subsystem:${conflicts[0].subsystem_tag}`
-      : `${conflicts[0].scope_pattern} overlaps ${conflicts[0].conflicting_scope_pattern}`;
+      ? `${conflicts[0].worktree} already owns subsystem:${conflicts[0].subsystem_tag}`
+      : `${conflicts[0].worktree} already owns ${conflicts[0].conflicting_scope_pattern} (requested ${conflicts[0].scope_pattern})`;
     logAuditEventTx(db, {
       eventType: 'scope_reservation_denied',
       status: 'denied',
@@ -837,7 +859,7 @@ function reserveLeaseScopesTx(db, lease) {
       leaseId: lease.id,
       details: JSON.stringify({ conflicts, summary }),
     });
-    throw new Error(`Scope reservation conflict: ${summary}`);
+    throw new Error(`Scope ownership conflict: ${summary}`);
   }
 
   const insert = db.prepare(`
@@ -1672,20 +1694,27 @@ export function createTask(db, { id, title, description, priority = 5 }) {
 }
 
 export function startTaskLease(db, taskId, worktree, agent) {
-  return withImmediateTransaction(db, () => {
-    const task = getTaskTx(db, taskId);
-    if (!task || task.status !== 'pending') {
-      return null;
-    }
+  try {
+    return withImmediateTransaction(db, () => {
+      const task = getTaskTx(db, taskId);
+      if (!task || task.status !== 'pending') {
+        return null;
+      }
 
-    db.prepare(`
-      UPDATE tasks
-      SET status='in_progress', worktree=?, agent=?, updated_at=datetime('now')
-      WHERE id=? AND status='pending'
-    `).run(worktree, agent || null, taskId);
+      db.prepare(`
+        UPDATE tasks
+        SET status='in_progress', worktree=?, agent=?, updated_at=datetime('now')
+        WHERE id=? AND status='pending'
+      `).run(worktree, agent || null, taskId);
 
-    return createLeaseTx(db, { taskId, worktree, agent });
-  });
+      return createLeaseTx(db, { taskId, worktree, agent });
+    });
+  } catch (err) {
+    if (String(err?.message || '').startsWith('Scope ownership conflict:')) {
+      return null;
+    }
+    throw err;
+  }
 }
 
 export function assignTask(db, taskId, worktree, agent) {
@@ -1693,14 +1722,52 @@ export function assignTask(db, taskId, worktree, agent) {
 }
 
 export function completeTask(db, taskId) {
-  withImmediateTransaction(db, () => {
+  return withImmediateTransaction(db, () => {
+    const task = getTaskTx(db, taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} does not exist.`);
+    }
+    if (task.status === 'done') {
+      return {
+        ok: false,
+        status: 'already_done',
+        task: getTaskTx(db, taskId),
+      };
+    }
+    if (task.status === 'failed') {
+      return {
+        ok: false,
+        status: 'failed',
+        task: getTaskTx(db, taskId),
+      };
+    }
+    if (task.status !== 'in_progress') {
+      return {
+        ok: false,
+        status: 'not_in_progress',
+        task: getTaskTx(db, taskId),
+      };
+    }
     const activeLease = getActiveLeaseForTaskTx(db, taskId);
+    if (!activeLease) {
+      return {
+        ok: false,
+        status: 'no_active_lease',
+        task: getTaskTx(db, taskId),
+      };
+    }
     finalizeTaskWithLeaseTx(db, taskId, activeLease, {
       taskStatus: 'done',
       leaseStatus: 'completed',
       auditStatus: 'allowed',
       auditEventType: 'task_completed',
     });
+    return {
+      ok: true,
+      status: 'completed',
+      had_active_lease: true,
+      task: getTaskTx(db, taskId),
+    };
   });
 }
 
@@ -1755,7 +1822,13 @@ export function failLeaseTask(db, leaseId, reason) {
 export function retryTask(db, taskId, reason = null) {
   return withImmediateTransaction(db, () => {
     const task = getTaskTx(db, taskId);
-    if (!task || !['failed', 'done'].includes(task.status)) {
+    if (!task) {
+      return null;
+    }
+    const activeLease = getActiveLeaseForTaskTx(db, taskId);
+    const retryable = ['failed', 'done'].includes(task.status)
+      || (task.status === 'in_progress' && !activeLease);
+    if (!retryable) {
       return null;
     }
 
@@ -1766,7 +1839,7 @@ export function retryTask(db, taskId, reason = null) {
           agent=NULL,
           completed_at=NULL,
           updated_at=datetime('now')
-      WHERE id=? AND status IN ('failed', 'done')
+      WHERE id=? AND status IN ('failed', 'done', 'in_progress')
     `).run(taskId);
 
     logAuditEventTx(db, {
@@ -2624,7 +2697,7 @@ export function getStaleLeases(db, staleAfterMinutes = DEFAULT_STALE_LEASE_MINUT
     FROM leases l
     JOIN tasks t ON l.task_id = t.id
     WHERE l.status='active'
-      AND l.heartbeat_at < datetime('now', ?)
+      AND l.heartbeat_at <= datetime('now', ?)
     ORDER BY l.heartbeat_at ASC
   `).all(`-${staleAfterMinutes} minutes`);
 }
@@ -2699,6 +2772,44 @@ export function reapStaleLeases(db, staleAfterMinutes = DEFAULT_STALE_LEASE_MINU
   });
 }
 
+export function pruneDatabaseMaintenance(db, { retentionDays = DB_PRUNE_RETENTION_DAYS } = {}) {
+  const retentionWindow = `-${Math.max(1, Number.parseInt(retentionDays, 10) || DB_PRUNE_RETENTION_DAYS)} days`;
+  return withImmediateTransaction(db, () => {
+    const releasedClaims = db.prepare(`
+      DELETE FROM file_claims
+      WHERE released_at IS NOT NULL
+        AND released_at <= datetime('now', ?)
+    `).run(retentionWindow).changes;
+
+    const releasedReservations = db.prepare(`
+      DELETE FROM scope_reservations
+      WHERE released_at IS NOT NULL
+        AND released_at <= datetime('now', ?)
+    `).run(retentionWindow).changes;
+
+    const finishedLeases = db.prepare(`
+      DELETE FROM leases
+      WHERE status != 'active'
+        AND finished_at IS NOT NULL
+        AND finished_at <= datetime('now', ?)
+    `).run(retentionWindow).changes;
+
+    const orphanedSnapshots = db.prepare(`
+      DELETE FROM worktree_snapshots
+      WHERE worktree NOT IN (
+        SELECT name FROM worktrees
+      )
+    `).run().changes;
+
+    return {
+      released_claims_pruned: releasedClaims,
+      finished_leases_pruned: finishedLeases,
+      released_scope_reservations_pruned: releasedReservations,
+      orphaned_snapshots_pruned: orphanedSnapshots,
+    };
+  });
+}
+
 // ─── File Claims ──────────────────────────────────────────────────────────────
 
 export function claimFiles(db, taskId, worktree, filePaths, agent) {
@@ -2746,7 +2857,18 @@ export function claimFiles(db, taskId, worktree, filePaths, agent) {
         throw new Error('One or more files are already actively claimed by another task.');
       }
 
-      insert.run(taskId, lease.id, normalizedPath, worktree, agent || null);
+      try {
+        insert.run(taskId, lease.id, normalizedPath, worktree, agent || null);
+      } catch (err) {
+        const message = String(err?.message || '').toLowerCase();
+        const isActiveClaimConstraint =
+          message.includes('idx_file_claims_active_path')
+          || (message.includes('unique') && message.includes('file_claims'));
+        if (isActiveClaimConstraint) {
+          throw new Error('One or more files are already actively claimed by another task.');
+        }
+        throw err;
+      }
       activeClaimByPath.set(normalizedPath, {
         task_id: taskId,
         lease_id: lease.id,

package/src/core/enforcement.js

@@ -1,18 +1,23 @@
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
 import { dirname, join, posix, relative, resolve } from 'path';
 import { execFileSync, spawnSync } from 'child_process';
 
 import {
   getActiveFileClaims,
+  touchBoundaryValidationState,
   getCompletedFileClaims,
   getLease,
-  getTaskSpec,
   getWorktree,
+  listWorktrees,
   getWorktreeSnapshotState,
   replaceWorktreeSnapshotState,
   getStaleLeases,
+  listScopeReservations,
   listAuditEvents,
   listLeases,
+  listTasks,
+  getTask,
+  getTaskSpec,
   logAuditEvent,
   updateWorktreeCompliance,
 } from './db.js';
@@ -30,6 +35,14 @@ const DEFAULT_ENFORCEMENT_POLICY = {
   allowed_generated_paths: [],
 };
 
+function normalizeFsPath(filePath) {
+  try {
+    return realpathSync(filePath);
+  } catch {
+    return resolve(filePath);
+  }
+}
+
 function getEnforcementPolicyPath(repoRoot) {
   return join(repoRoot, '.switchman', 'enforcement.json');
 }
@@ -125,7 +138,19 @@ function diffSnapshots(previousSnapshot, currentSnapshot) {
 }
 
 function getLeaseScopePatterns(db, lease) {
-  return getTaskSpec(db, lease.task_id)?.allowed_paths || [];
+  const reservations = listScopeReservations(db, { leaseId: lease.id });
+  const scopePatterns = reservations
+    .filter((reservation) => reservation.ownership_level === 'path_scope' && reservation.scope_pattern)
+    .map((reservation) => reservation.scope_pattern);
+  return [...new Set(scopePatterns)];
+}
+
+function getLeaseSubsystemTags(db, lease) {
+  const reservations = listScopeReservations(db, { leaseId: lease.id });
+  const subsystemTags = reservations
+    .filter((reservation) => reservation.ownership_level === 'subsystem' && reservation.subsystem_tag)
+    .map((reservation) => reservation.subsystem_tag);
+  return [...new Set(subsystemTags)];
 }
 
 function findScopedLeaseOwner(db, leases, filePath, excludeLeaseId = null) {
@@ -139,6 +164,18 @@ function findScopedLeaseOwner(db, leases, filePath, excludeLeaseId = null) {
   return null;
 }
 
+function findSubsystemLeaseOwner(db, leases, subsystemTags, excludeLeaseId = null) {
+  if (!subsystemTags.length) return null;
+  for (const lease of leases) {
+    if (excludeLeaseId && lease.id === excludeLeaseId) continue;
+    const leaseTags = getLeaseSubsystemTags(db, lease);
+    if (leaseTags.some((tag) => subsystemTags.includes(tag))) {
+      return lease;
+    }
+  }
+  return null;
+}
+
 function normalizeDirectoryScopeRoot(pattern) {
   return String(pattern || '').replace(/\\/g, '/').replace(/\/\*\*$/, '').replace(/\/\*$/, '').replace(/\/+$/, '');
 }
@@ -163,8 +200,13 @@ function resolveLeasePathOwnership(db, lease, filePath, activeClaims, activeLeas
   }
 
   const ownScopePatterns = getLeaseScopePatterns(db, lease);
+  const ownSubsystemTags = getLeaseSubsystemTags(db, lease);
   const ownScopeMatch = ownScopePatterns.length > 0 && matchesPathPatterns(filePath, ownScopePatterns);
   if (ownScopeMatch) {
+    const foreignSubsystemOwner = findSubsystemLeaseOwner(db, activeLeases, ownSubsystemTags, lease.id);
+    if (foreignSubsystemOwner) {
+      return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
+    }
     const foreignScopeOwner = findScopedLeaseOwner(db, activeLeases, filePath, lease.id);
     if (foreignScopeOwner) {
       return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
@@ -177,9 +219,25 @@ function resolveLeasePathOwnership(db, lease, filePath, activeClaims, activeLeas
     return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
   }
 
+  const foreignSubsystemOwner = findSubsystemLeaseOwner(db, activeLeases, ownSubsystemTags, lease.id);
+  if (foreignSubsystemOwner) {
+    return { ok: false, reason_code: 'path_scoped_by_other_lease', claim: null, ownership_type: null };
+  }
+
   return { ok: false, reason_code: 'path_not_claimed', claim: null, ownership_type: null };
 }
 
+function completedScopedTaskOwnsPath(db, completedTasks, filePath) {
+  for (const task of completedTasks) {
+    const taskSpec = getTaskSpec(db, task.id);
+    const allowedPaths = Array.isArray(taskSpec?.allowed_paths) ? taskSpec.allowed_paths : [];
+    if (allowedPaths.length > 0 && matchesPathPatterns(filePath, allowedPaths)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 function classifyObservedPath(db, repoRoot, worktree, filePath, options = {}) {
   const activeLeases = options.activeLeases || listLeases(db, 'active');
   const activeClaims = options.activeClaims || getActiveFileClaims(db);
@@ -188,12 +246,28 @@ function classifyObservedPath(db, repoRoot, worktree, filePath, options = {}) {
 
   const activeLease = activeLeases.find((lease) => lease.worktree === worktree.name) || null;
   const claim = activeClaims.find((item) => item.file_path === filePath && item.worktree === worktree.name) || null;
+  const foreignClaim = activeClaims.find((item) => item.file_path === filePath && item.worktree !== worktree.name) || null;
+  const foreignScopeOwner = findScopedLeaseOwner(db, activeLeases, filePath, activeLease?.id || null);
 
   if (!activeLease) {
-    return { status: 'denied', reason_code: 'no_active_lease', lease: null, claim };
+    return {
+      status: 'denied',
+      reason_code: 'no_active_lease',
+      lease: null,
+      claim,
+      owner_claim: foreignClaim,
+      owner_lease: foreignScopeOwner,
+    };
   }
   if (staleLeaseIds.has(activeLease.id)) {
-    return { status: 'denied', reason_code: 'lease_expired', lease: activeLease, claim };
+    return {
+      status: 'denied',
+      reason_code: 'lease_expired',
+      lease: activeLease,
+      claim,
+      owner_claim: foreignClaim,
+      owner_lease: foreignScopeOwner,
+    };
   }
   const ownership = resolveLeasePathOwnership(db, activeLease, filePath, activeClaims, activeLeases);
   if (ownership.ok) {
@@ -203,12 +277,30 @@ function classifyObservedPath(db, repoRoot, worktree, filePath, options = {}) {
       lease: activeLease,
       claim: ownership.claim ?? claim,
       ownership_type: ownership.ownership_type,
+      owner_claim: null,
+      owner_lease: null,
     };
   }
   if (matchesPathPatterns(filePath, policy.allowed_generated_paths || [])) {
-    return { status: 'allowed', reason_code: 'policy_exception_allowed', lease: activeLease, claim: null, ownership_type: 'policy' };
+    return {
+      status: 'allowed',
+      reason_code: 'policy_exception_allowed',
+      lease: activeLease,
+      claim: null,
+      ownership_type: 'policy',
+      owner_claim: null,
+      owner_lease: null,
+    };
   }
-  return { status: 'denied', reason_code: ownership.reason_code, lease: activeLease, claim: ownership.claim ?? claim, ownership_type: null };
+  return {
+    status: 'denied',
+    reason_code: ownership.reason_code,
+    lease: activeLease,
+    claim: ownership.claim ?? claim,
+    ownership_type: null,
+    owner_claim: ownership.claim ?? foreignClaim,
+    owner_lease: foreignScopeOwner,
+  };
 }
 
 function normalizeRepoPath(repoRoot, targetPath) {
@@ -361,6 +453,9 @@ export function validateLeaseAccess(db, { leaseId, worktree = null }) {
 }
 
 function logWriteEvent(db, status, reasonCode, validation, eventType, details = null) {
+  if (status === 'allowed' && validation.lease?.id) {
+    touchBoundaryValidationState(db, validation.lease.id, `write:${details?.operation || 'unknown'}`);
+  }
   logAuditEvent(db, {
     eventType,
     status,
@@ -716,6 +811,9 @@ export function evaluateWorktreeCompliance(db, repoRoot, worktree, options = {})
   const activeLeases = options.activeLeases || listLeases(db, 'active');
   const activeClaims = options.activeClaims || getActiveFileClaims(db);
   const completedClaims = options.completedClaims || getCompletedFileClaims(db, worktree.name);
+  const completedTasks = options.completedTasks
+    || listTasks(db)
+      .filter((task) => task.status === 'done' && task.worktree === worktree.name);
 
   const changedFiles = getWorktreeChangedFiles(worktree.path, repoRoot);
   const activeLease = activeLeases.find((lease) => lease.worktree === worktree.name) || null;
@@ -728,7 +826,7 @@ export function evaluateWorktreeCompliance(db, repoRoot, worktree, options = {})
   for (const file of changedFiles) {
     const completedClaim = completedClaimsByPath.get(file);
     if (!activeLease) {
-      if (completedClaim) {
+      if (completedClaim || completedScopedTaskOwnsPath(db, completedTasks, file)) {
         continue;
       }
       violations.push({ file, reason_code: 'no_active_lease' });
@@ -838,6 +936,9 @@ export function monitorWorktreesOnce(db, repoRoot, worktrees, options = {}) {
         reason_code: classification.reason_code,
         lease_id: classification.lease?.id ?? null,
         task_id: classification.lease?.task_id ?? null,
+        owner_worktree: classification.owner_claim?.worktree || classification.owner_lease?.worktree || null,
+        owner_task_id: classification.owner_claim?.task_id || classification.owner_lease?.task_id || null,
+        owner_task_title: classification.owner_claim?.task_title || getTask(db, classification.owner_lease?.task_id || '')?.title || null,
         enforcement_action: null,
         quarantine_path: null,
       };
@@ -853,6 +954,10 @@ export function monitorWorktreesOnce(db, repoRoot, worktrees, options = {}) {
         details: JSON.stringify({ change_type: change.change_type }),
       });
 
+      if (classification.status === 'allowed' && classification.lease?.id) {
+        touchBoundaryValidationState(db, classification.lease.id, `observed:${change.change_type}`);
+      }
+
       if (classification.status === 'denied') {
         updateWorktreeCompliance(db, worktree.name, COMPLIANCE_STATES.NON_COMPLIANT);
         if (options.quarantine) {
@@ -894,9 +999,16 @@ export function runCommitGate(db, repoRoot, { cwd = process.cwd(), worktreeName
   const currentWorktree = worktreeName
     ? null
     : getCurrentWorktree(repoRoot, cwd);
+  const registeredWorktree = worktreeName
+    ? getWorktree(db, worktreeName)
+    : listWorktrees(db).find((entry) => normalizeFsPath(entry.path) === normalizeFsPath(cwd))
+      || (currentWorktree
+        ? listWorktrees(db).find((entry) => normalizeFsPath(entry.path) === normalizeFsPath(currentWorktree.path))
+        : null)
+      || null;
   const resolvedWorktree = worktreeName
-    ? { name: worktreeName, path: cwd }
-    : currentWorktree;
+    ? { name: worktreeName, path: registeredWorktree?.path || cwd }
+    : registeredWorktree || currentWorktree;
 
   if (!resolvedWorktree) {
     const result = {

package/src/core/ignore.js

@@ -1,4 +1,5 @@
 export const DEFAULT_SCAN_IGNORE_PATTERNS = [
+  '.mcp.json',
   'node_modules/**',
   '.git/**',
   '.mcp.json',