switchman-dev 0.1.3 → 0.1.5

package/src/core/db.js

@@ -273,6 +273,38 @@ function ensureSchema(db) {
       area           TEXT,
       updated_at     TEXT NOT NULL DEFAULT (datetime('now'))
     );
+
+    CREATE TABLE IF NOT EXISTS merge_queue (
+      id                 TEXT PRIMARY KEY,
+      source_type        TEXT NOT NULL,
+      source_ref         TEXT NOT NULL,
+      source_worktree    TEXT,
+      source_pipeline_id TEXT,
+      target_branch      TEXT NOT NULL DEFAULT 'main',
+      status             TEXT NOT NULL DEFAULT 'queued',
+      retry_count        INTEGER NOT NULL DEFAULT 0,
+      max_retries        INTEGER NOT NULL DEFAULT 1,
+      last_error_code    TEXT,
+      last_error_summary TEXT,
+      next_action        TEXT,
+      merged_commit      TEXT,
+      submitted_by       TEXT,
+      created_at         TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at         TEXT NOT NULL DEFAULT (datetime('now')),
+      last_attempt_at    TEXT,
+      started_at         TEXT,
+      finished_at        TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS merge_queue_events (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      queue_item_id TEXT NOT NULL,
+      event_type    TEXT NOT NULL,
+      status        TEXT,
+      details       TEXT,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+      FOREIGN KEY(queue_item_id) REFERENCES merge_queue(id) ON DELETE CASCADE
+    );
   `);
 
   const fileClaimColumns = getTableColumns(db, 'file_claims');
@@ -302,6 +334,11 @@ function ensureSchema(db) {
     db.exec(`ALTER TABLE audit_log ADD COLUMN signature TEXT`);
   }
 
+  const mergeQueueColumns = getTableColumns(db, 'merge_queue');
+  if (mergeQueueColumns.length > 0 && !mergeQueueColumns.includes('last_attempt_at')) {
+    db.exec(`ALTER TABLE merge_queue ADD COLUMN last_attempt_at TEXT`);
+  }
+
   db.exec(`
     CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
     CREATE INDEX IF NOT EXISTS idx_leases_task ON leases(task_id);
@@ -334,6 +371,10 @@ function ensureSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_dependency_invalidations_status ON dependency_invalidations(status);
     CREATE INDEX IF NOT EXISTS idx_code_objects_file_path ON code_objects(file_path);
     CREATE INDEX IF NOT EXISTS idx_code_objects_name ON code_objects(name);
+    CREATE INDEX IF NOT EXISTS idx_merge_queue_status ON merge_queue(status);
+    CREATE INDEX IF NOT EXISTS idx_merge_queue_created_at ON merge_queue(created_at);
+    CREATE INDEX IF NOT EXISTS idx_merge_queue_pipeline_id ON merge_queue(source_pipeline_id);
+    CREATE INDEX IF NOT EXISTS idx_merge_queue_events_item ON merge_queue_events(queue_item_id);
   `);
 
   migrateLegacyAuditLog(db);
@@ -1372,6 +1413,198 @@ export function getTask(db, taskId) {
   return db.prepare(`SELECT * FROM tasks WHERE id=?`).get(taskId);
 }
 
+export function enqueueMergeItem(db, {
+  id = null,
+  sourceType,
+  sourceRef,
+  sourceWorktree = null,
+  sourcePipelineId = null,
+  targetBranch = 'main',
+  maxRetries = 1,
+  submittedBy = null,
+} = {}) {
+  const itemId = id || makeId('mq');
+  db.prepare(`
+    INSERT INTO merge_queue (
+      id, source_type, source_ref, source_worktree, source_pipeline_id,
+      target_branch, status, retry_count, max_retries, submitted_by
+    )
+    VALUES (?, ?, ?, ?, ?, ?, 'queued', 0, ?, ?)
+  `).run(
+    itemId,
+    sourceType,
+    sourceRef,
+    sourceWorktree || null,
+    sourcePipelineId || null,
+    targetBranch || 'main',
+    Math.max(0, Number.parseInt(maxRetries, 10) || 0),
+    submittedBy || null,
+  );
+
+  logMergeQueueEvent(db, itemId, {
+    eventType: 'merge_queue_enqueued',
+    status: 'queued',
+    details: JSON.stringify({
+      source_type: sourceType,
+      source_ref: sourceRef,
+      source_worktree: sourceWorktree || null,
+      source_pipeline_id: sourcePipelineId || null,
+      target_branch: targetBranch || 'main',
+    }),
+  });
+
+  return getMergeQueueItem(db, itemId);
+}
+
+export function listMergeQueue(db, { status = null } = {}) {
+  if (status) {
+    return db.prepare(`
+      SELECT *
+      FROM merge_queue
+      WHERE status=?
+      ORDER BY datetime(created_at) ASC, id ASC
+    `).all(status);
+  }
+
+  return db.prepare(`
+    SELECT *
+    FROM merge_queue
+    ORDER BY datetime(created_at) ASC, id ASC
+  `).all();
+}
+
+export function getMergeQueueItem(db, itemId) {
+  return db.prepare(`
+    SELECT *
+    FROM merge_queue
+    WHERE id=?
+  `).get(itemId);
+}
+
+export function listMergeQueueEvents(db, itemId, { limit = 10 } = {}) {
+  return db.prepare(`
+    SELECT *
+    FROM merge_queue_events
+    WHERE queue_item_id=?
+    ORDER BY id DESC
+    LIMIT ?
+  `).all(itemId, limit);
+}
+
+export function logMergeQueueEvent(db, itemId, {
+  eventType,
+  status = null,
+  details = null,
+} = {}) {
+  db.prepare(`
+    INSERT INTO merge_queue_events (queue_item_id, event_type, status, details)
+    VALUES (?, ?, ?, ?)
+  `).run(itemId, eventType, status || null, details == null ? null : String(details));
+}
+
+export function startMergeQueueItem(db, itemId) {
+  return withImmediateTransaction(db, () => {
+    const item = getMergeQueueItem(db, itemId);
+    if (!item || !['queued', 'retrying'].includes(item.status)) {
+      return null;
+    }
+
+    db.prepare(`
+      UPDATE merge_queue
+      SET status='validating',
+          started_at=COALESCE(started_at, datetime('now')),
+          last_attempt_at=datetime('now'),
+          updated_at=datetime('now')
+      WHERE id=? AND status IN ('queued', 'retrying')
+    `).run(itemId);
+
+    logMergeQueueEvent(db, itemId, {
+      eventType: 'merge_queue_started',
+      status: 'validating',
+    });
+
+    return getMergeQueueItem(db, itemId);
+  });
+}
+
+export function markMergeQueueState(db, itemId, {
+  status,
+  lastErrorCode = null,
+  lastErrorSummary = null,
+  nextAction = null,
+  mergedCommit = null,
+  incrementRetry = false,
+} = {}) {
+  const terminal = ['merged', 'blocked', 'failed', 'canceled'].includes(status);
+  db.prepare(`
+    UPDATE merge_queue
+    SET status=?,
+        last_error_code=?,
+        last_error_summary=?,
+        next_action=?,
+        merged_commit=COALESCE(?, merged_commit),
+        retry_count=retry_count + ?,
+        updated_at=datetime('now'),
+        finished_at=CASE WHEN ? THEN datetime('now') ELSE finished_at END
+    WHERE id=?
+  `).run(
+    status,
+    lastErrorCode || null,
+    lastErrorSummary || null,
+    nextAction || null,
+    mergedCommit || null,
+    incrementRetry ? 1 : 0,
+    terminal ? 1 : 0,
+    itemId,
+  );
+
+  logMergeQueueEvent(db, itemId, {
+    eventType: 'merge_queue_state_changed',
+    status,
+    details: JSON.stringify({
+      last_error_code: lastErrorCode || null,
+      last_error_summary: lastErrorSummary || null,
+      next_action: nextAction || null,
+      merged_commit: mergedCommit || null,
+      increment_retry: incrementRetry,
+    }),
+  });
+
+  return getMergeQueueItem(db, itemId);
+}
+
+export function retryMergeQueueItem(db, itemId) {
+  const item = getMergeQueueItem(db, itemId);
+  if (!item || !['blocked', 'failed'].includes(item.status)) {
+    return null;
+  }
+
+  db.prepare(`
+    UPDATE merge_queue
+    SET status='retrying',
+        last_error_code=NULL,
+        last_error_summary=NULL,
+        next_action=NULL,
+        finished_at=NULL,
+        updated_at=datetime('now')
+    WHERE id=?
+  `).run(itemId);
+
+  logMergeQueueEvent(db, itemId, {
+    eventType: 'merge_queue_retried',
+    status: 'retrying',
+  });
+
+  return getMergeQueueItem(db, itemId);
+}
+
+export function removeMergeQueueItem(db, itemId) {
+  const item = getMergeQueueItem(db, itemId);
+  if (!item) return null;
+  db.prepare(`DELETE FROM merge_queue WHERE id=?`).run(itemId);
+  return item;
+}
+
 export function upsertTaskSpec(db, taskId, spec) {
   db.prepare(`
     INSERT INTO task_specs (task_id, spec_json, updated_at)
@@ -1626,7 +1859,7 @@ export function getStaleLeases(db, staleAfterMinutes = DEFAULT_STALE_LEASE_MINUT
   `).all(`-${staleAfterMinutes} minutes`);
 }
 
-export function reapStaleLeases(db, staleAfterMinutes = DEFAULT_STALE_LEASE_MINUTES) {
+export function reapStaleLeases(db, staleAfterMinutes = DEFAULT_STALE_LEASE_MINUTES, { requeueTask = true } = {}) {
   return withImmediateTransaction(db, () => {
     const staleLeases = getStaleLeases(db, staleAfterMinutes);
     if (!staleLeases.length) {
@@ -1655,11 +1888,28 @@ export function reapStaleLeases(db, staleAfterMinutes = DEFAULT_STALE_LEASE_MINU
         )
     `);
 
+    const failTaskForStaleLease = db.prepare(`
+      UPDATE tasks
+      SET status='failed',
+          description=COALESCE(description,'') || '\nFAILED: lease_expired: stale lease reaped',
+          updated_at=datetime('now')
+      WHERE id=? AND status='in_progress'
+        AND NOT EXISTS (
+          SELECT 1 FROM leases
+          WHERE task_id=?
+            AND status='active'
+        )
+    `);
+
     for (const lease of staleLeases) {
       expireLease.run(lease.id);
       releaseClaimsForLeaseTx(db, lease.id);
       releaseScopeReservationsForLeaseTx(db, lease.id);
-      resetTask.run(lease.task_id, lease.task_id);
+      if (requeueTask) {
+        resetTask.run(lease.task_id, lease.task_id);
+      } else {
+        failTaskForStaleLease.run(lease.task_id, lease.task_id);
+      }
       touchWorktreeLeaseState(db, lease.worktree, lease.agent, 'idle');
       logAuditEventTx(db, {
         eventType: 'lease_expired',

package/src/core/git.js

@@ -3,7 +3,7 @@
  * Worktree discovery and conflict detection via git merge-tree
  */
 
-import { execSync, spawnSync } from 'child_process';
+import { execFileSync, execSync, spawnSync } from 'child_process';
 import { existsSync, realpathSync } from 'fs';
 import { join, relative, resolve, basename } from 'path';
 import { filterIgnoredPaths } from './ignore.js';
@@ -266,6 +266,79 @@ export function getWorktreeBranch(worktreePath) {
   }
 }
 
+export function gitBranchExists(repoRoot, branch) {
+  const result = spawnSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+  });
+  return result.status === 0;
+}
+
+export function gitRevParse(repoRoot, ref) {
+  try {
+    return execFileSync('git', ['rev-parse', ref], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function gitGetCurrentBranch(repoRoot) {
+  try {
+    return execFileSync('git', ['branch', '--show-current'], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export function gitCheckout(repoRoot, ref) {
+  execFileSync('git', ['checkout', ref], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+export function gitRebaseOnto(repoRoot, baseBranch, topicBranch) {
+  const previousBranch = gitGetCurrentBranch(repoRoot);
+  try {
+    gitCheckout(repoRoot, topicBranch);
+    execFileSync('git', ['rebase', baseBranch], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } finally {
+    if (previousBranch && previousBranch !== topicBranch) {
+      try { gitCheckout(repoRoot, previousBranch); } catch { /* no-op */ }
+    }
+  }
+}
+
+export function gitMergeBranchInto(repoRoot, baseBranch, topicBranch) {
+  const previousBranch = gitGetCurrentBranch(repoRoot);
+  try {
+    gitCheckout(repoRoot, baseBranch);
+    execFileSync('git', ['merge', '--ff-only', topicBranch], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return gitRevParse(repoRoot, 'HEAD');
+  } finally {
+    if (previousBranch && previousBranch !== baseBranch) {
+      try { gitCheckout(repoRoot, previousBranch); } catch { /* no-op */ }
+    }
+  }
+}
+
 /**
  * Create a new git worktree
  */

package/src/core/ignore.js

@@ -1,6 +1,8 @@
 export const DEFAULT_SCAN_IGNORE_PATTERNS = [
   'node_modules/**',
   '.git/**',
+  '.mcp.json',
+  '.cursor/mcp.json',
   '.switchman/**',
   'dist/**',
   'build/**',

package/src/core/mcp.js

@@ -1,19 +1,23 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
 import { join } from 'path';
 
-export function getSwitchmanMcpConfig() {
+export function getSwitchmanMcpServers() {
   return {
-    mcpServers: {
-      switchman: {
-        command: 'switchman-mcp',
-        args: [],
-      },
+    switchman: {
+      command: 'switchman-mcp',
+      args: [],
     },
   };
 }
 
-export function upsertProjectMcpConfig(targetDir) {
-  const configPath = join(targetDir, '.mcp.json');
+export function getSwitchmanMcpConfig() {
+  return {
+    mcpServers: getSwitchmanMcpServers(),
+  };
+}
+
+function upsertMcpConfigFile(configPath) {
   let config = {};
   let created = true;
 
@@ -21,13 +25,15 @@ export function upsertProjectMcpConfig(targetDir) {
     created = false;
     const raw = readFileSync(configPath, 'utf8').trim();
     config = raw ? JSON.parse(raw) : {};
+  } else {
+    mkdirSync(join(configPath, '..'), { recursive: true });
   }
 
   const nextConfig = {
     ...config,
     mcpServers: {
       ...(config.mcpServers || {}),
-      ...getSwitchmanMcpConfig().mcpServers,
+      ...getSwitchmanMcpServers(),
     },
   };
 
@@ -45,3 +51,26 @@ export function upsertProjectMcpConfig(targetDir) {
     changed,
   };
 }
+
+export function upsertCursorProjectMcpConfig(targetDir) {
+  return upsertMcpConfigFile(join(targetDir, '.cursor', 'mcp.json'));
+}
+
+export function upsertAllProjectMcpConfigs(targetDir) {
+  return [
+    upsertProjectMcpConfig(targetDir),
+    upsertCursorProjectMcpConfig(targetDir),
+  ];
+}
+
+export function upsertProjectMcpConfig(targetDir) {
+  return upsertMcpConfigFile(join(targetDir, '.mcp.json'));
+}
+
+export function getWindsurfMcpConfigPath(homeDir = homedir()) {
+  return join(homeDir, '.codeium', 'mcp_config.json');
+}
+
+export function upsertWindsurfMcpConfig(homeDir = homedir()) {
+  return upsertMcpConfigFile(getWindsurfMcpConfigPath(homeDir));
+}

package/src/core/outcome.js

@@ -1,4 +1,4 @@
-import { getActiveFileClaims, getTask, getTaskSpec, getWorktree } from './db.js';
+import { getActiveFileClaims, getLeaseExecutionContext, getTask, getTaskSpec, getWorktree, touchBoundaryValidationState } from './db.js';
 import { getWorktreeChangedFiles } from './git.js';
 import { matchesPathPatterns } from './ignore.js';
 
@@ -20,19 +20,48 @@ function fileMatchesKeyword(filePath, keyword) {
   return normalizedKeyword.length >= 3 && normalizedPath.includes(normalizedKeyword);
 }
 
-export function evaluateTaskOutcome(db, repoRoot, { taskId }) {
+function resolveExecution(db, { taskId = null, leaseId = null } = {}) {
+  if (leaseId) {
+    const execution = getLeaseExecutionContext(db, leaseId);
+    if (!execution?.task) {
+      return { task: null, taskSpec: null, worktree: null, leaseId };
+    }
+    return {
+      task: execution.task,
+      taskSpec: execution.task_spec,
+      worktree: execution.worktree,
+      leaseId: execution.lease?.id || leaseId,
+    };
+  }
+
+  if (!taskId) {
+    return { task: null, taskSpec: null, worktree: null, leaseId: null };
+  }
+
   const task = getTask(db, taskId);
-  const taskSpec = getTaskSpec(db, taskId);
+  return {
+    task,
+    taskSpec: task ? getTaskSpec(db, taskId) : null,
+    worktree: task?.worktree ? getWorktree(db, task.worktree) : null,
+    leaseId: null,
+  };
+}
+
+export function evaluateTaskOutcome(db, repoRoot, { taskId = null, leaseId = null } = {}) {
+  const execution = resolveExecution(db, { taskId, leaseId });
+  const task = execution.task;
+  const taskSpec = execution.taskSpec;
+
   if (!task || !task.worktree) {
     return {
       status: 'failed',
-      reason_code: 'task_not_assigned',
+      reason_code: taskId || leaseId ? 'task_not_assigned' : 'task_identity_required',
       changed_files: [],
-      findings: ['task has no assigned worktree'],
+      findings: [taskId || leaseId ? 'task has no assigned worktree' : 'task outcome requires a taskId or leaseId'],
     };
   }
 
-  const worktree = getWorktree(db, task.worktree);
+  const worktree = execution.worktree;
   if (!worktree) {
     return {
       status: 'failed',
@@ -44,7 +73,7 @@ export function evaluateTaskOutcome(db, repoRoot, { taskId }) {
 
   const changedFiles = getWorktreeChangedFiles(worktree.path, repoRoot);
   const activeClaims = getActiveFileClaims(db)
-    .filter((claim) => claim.task_id === taskId && claim.worktree === task.worktree)
+    .filter((claim) => claim.task_id === task.id && claim.worktree === task.worktree)
     .map((claim) => claim.file_path);
   const changedOutsideClaims = changedFiles.filter((filePath) => !activeClaims.includes(filePath));
   const changedInsideClaims = changedFiles.filter((filePath) => activeClaims.includes(filePath));
@@ -128,9 +157,7 @@ export function evaluateTaskOutcome(db, repoRoot, { taskId }) {
   const matchedObjectiveKeywords = objectiveKeywords.filter((keyword) =>
     changedFiles.some((filePath) => fileMatchesKeyword(filePath, keyword)),
   );
-  const minimumKeywordMatches = taskSpec?.risk_level === 'high'
-    ? Math.min(2, objectiveKeywords.length)
-    : Math.min(1, objectiveKeywords.length);
+  const minimumKeywordMatches = Math.min(1, objectiveKeywords.length);
 
   if (objectiveKeywords.length > 0 && matchedObjectiveKeywords.length < minimumKeywordMatches) {
     findings.push(`changed files do not clearly satisfy task objective keywords: ${objectiveKeywords.join(', ')}`);
@@ -138,16 +165,26 @@ export function evaluateTaskOutcome(db, repoRoot, { taskId }) {
       status: 'needs_followup',
       reason_code: 'objective_not_evidenced',
       changed_files: changedFiles,
+      task_id: task.id,
+      lease_id: execution.leaseId,
       findings,
     };
   }
 
-  return {
+  const result = {
     status: 'accepted',
     reason_code: null,
     changed_files: changedFiles,
+    task_id: task.id,
+    lease_id: execution.leaseId,
     task_spec: taskSpec,
     claimed_files: activeClaims,
     findings: changedInsideClaims.length > 0 ? ['changes stayed within claimed scope'] : [],
   };
+
+  if (execution.leaseId) {
+    touchBoundaryValidationState(db, execution.leaseId, 'task_outcome_accepted');
+  }
+
+  return result;
 }

package/src/core/policy.js

@@ -0,0 +1,49 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+export const DEFAULT_LEASE_POLICY = {
+  heartbeat_interval_seconds: 60,
+  stale_after_minutes: 15,
+  reap_on_status_check: false,
+  requeue_task_on_reap: true,
+};
+
+export function getLeasePolicyPath(repoRoot) {
+  return join(repoRoot, '.switchman', 'lease-policy.json');
+}
+
+export function loadLeasePolicy(repoRoot) {
+  const policyPath = getLeasePolicyPath(repoRoot);
+  if (!existsSync(policyPath)) {
+    return { ...DEFAULT_LEASE_POLICY };
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(policyPath, 'utf8'));
+    return {
+      ...DEFAULT_LEASE_POLICY,
+      ...parsed,
+      heartbeat_interval_seconds: Number.isFinite(parsed?.heartbeat_interval_seconds) ? parsed.heartbeat_interval_seconds : DEFAULT_LEASE_POLICY.heartbeat_interval_seconds,
+      stale_after_minutes: Number.isFinite(parsed?.stale_after_minutes) ? parsed.stale_after_minutes : DEFAULT_LEASE_POLICY.stale_after_minutes,
+      reap_on_status_check: typeof parsed?.reap_on_status_check === 'boolean' ? parsed.reap_on_status_check : DEFAULT_LEASE_POLICY.reap_on_status_check,
+      requeue_task_on_reap: typeof parsed?.requeue_task_on_reap === 'boolean' ? parsed.requeue_task_on_reap : DEFAULT_LEASE_POLICY.requeue_task_on_reap,
+    };
+  } catch {
+    return { ...DEFAULT_LEASE_POLICY };
+  }
+}
+
+export function writeLeasePolicy(repoRoot, policy = {}) {
+  const policyPath = getLeasePolicyPath(repoRoot);
+  mkdirSync(dirname(policyPath), { recursive: true });
+  const normalized = {
+    ...DEFAULT_LEASE_POLICY,
+    ...policy,
+    heartbeat_interval_seconds: Math.max(1, Number.parseInt(policy.heartbeat_interval_seconds, 10) || DEFAULT_LEASE_POLICY.heartbeat_interval_seconds),
+    stale_after_minutes: Math.max(1, Number.parseInt(policy.stale_after_minutes, 10) || DEFAULT_LEASE_POLICY.stale_after_minutes),
+    reap_on_status_check: typeof policy.reap_on_status_check === 'boolean' ? policy.reap_on_status_check : DEFAULT_LEASE_POLICY.reap_on_status_check,
+    requeue_task_on_reap: typeof policy.requeue_task_on_reap === 'boolean' ? policy.requeue_task_on_reap : DEFAULT_LEASE_POLICY.requeue_task_on_reap,
+  };
+  writeFileSync(policyPath, `${JSON.stringify(normalized, null, 2)}\n`);
+  return policyPath;
+}