switchman-dev 0.1.7 → 0.1.8

package/src/core/pipeline.js

@@ -1164,49 +1164,80 @@ function runPipelineIteration(
         retryBackoffMs,
         timeoutMs,
       });
-      const beforeHead = getHeadRevision(assignment.worktree_path);
-      const result = spawnSync(command, args, {
-        cwd: assignment.worktree_path,
-        env: buildLaunchEnv(
-          repoRoot,
-          { id: assignment.task_id, title: assignment.title, task_spec: assignment.task_spec },
-          { id: assignment.lease_id },
-          { name: assignment.worktree, path: assignment.worktree_path },
-        ),
-        encoding: 'utf8',
-        timeout: executionPolicy.timeout_ms > 0 ? executionPolicy.timeout_ms : undefined,
-      });
-      const afterHead = getHeadRevision(assignment.worktree_path);
-
-      const timedOut = result.error?.code === 'ETIMEDOUT';
-      const commandOk = !result.error && result.status === 0;
-      let evaluation = commandOk
-        ? evaluateTaskOutcome(db, repoRoot, { leaseId: assignment.lease_id })
-        : null;
-      if (commandOk && evaluation?.reason_code === 'no_changes_detected' && beforeHead && afterHead && beforeHead !== afterHead) {
-        evaluation = {
-          status: 'accepted',
-          reason_code: null,
-          changed_files: [],
-          claimed_files: [],
-          findings: ['task created a new commit with no remaining uncommitted diff'],
-        };
-      }
-      const ok = commandOk && evaluation?.status === 'accepted';
+      let result = { status: null, stdout: '', stderr: '', error: null };
+      let timedOut = false;
+      let evaluation = null;
+      let ok = false;
+      let reasonCode = 'agent_command_failed';
       let retry = {
         retried: false,
         retry_attempt: getTaskRetryCount(db, assignment.task_id),
         retries_remaining: Math.max(0, executionPolicy.max_retries - getTaskRetryCount(db, assignment.task_id)),
         retry_delay_ms: 0,
       };
+
+      try {
+        const beforeHead = getHeadRevision(assignment.worktree_path);
+        result = spawnSync(command, args, {
+          cwd: assignment.worktree_path,
+          env: buildLaunchEnv(
+            repoRoot,
+            { id: assignment.task_id, title: assignment.title, task_spec: assignment.task_spec },
+            { id: assignment.lease_id },
+            { name: assignment.worktree, path: assignment.worktree_path },
+          ),
+          encoding: 'utf8',
+          timeout: executionPolicy.timeout_ms > 0 ? executionPolicy.timeout_ms : undefined,
+        });
+        const afterHead = getHeadRevision(assignment.worktree_path);
+
+        timedOut = result.error?.code === 'ETIMEDOUT';
+        const commandOk = !result.error && result.status === 0;
+        evaluation = commandOk
+          ? evaluateTaskOutcome(db, repoRoot, { leaseId: assignment.lease_id })
+          : null;
+        if (commandOk && evaluation?.reason_code === 'no_changes_detected' && beforeHead && afterHead && beforeHead !== afterHead) {
+          evaluation = {
+            status: 'accepted',
+            reason_code: null,
+            changed_files: [],
+            claimed_files: [],
+            findings: ['task created a new commit with no remaining uncommitted diff'],
+          };
+        }
+        ok = commandOk && evaluation?.status === 'accepted';
+        reasonCode = timedOut
+          ? 'task_execution_timeout'
+          : ok
+            ? null
+            : 'agent_command_failed';
+      } catch (err) {
+        result = {
+          status: null,
+          stdout: result.stdout || '',
+          stderr: `${result.stderr || ''}${result.stderr ? '\n' : ''}${err.message}`,
+          error: err,
+        };
+        timedOut = false;
+        evaluation = {
+          status: 'rejected',
+          reason_code: 'pipeline_execution_internal_error',
+          findings: [err.message],
+        };
+        ok = false;
+        reasonCode = 'pipeline_execution_internal_error';
+      }
+
       if (ok) {
         completeLeaseTask(db, assignment.lease_id);
       } else {
-        const failureReason = !commandOk
-          ? (timedOut
-            ? `agent command timed out after ${executionPolicy.timeout_ms}ms`
-            : (result.error?.message || `agent command exited with status ${result.status}`))
-          : `${evaluation.reason_code}: ${evaluation.findings.join('; ')}`;
+        const failureReason = result.error && !timedOut && result.status === null
+          ? `${reasonCode}: ${result.error.message}`
+          : result.error || result.status !== 0
+            ? (timedOut
+              ? `agent command timed out after ${executionPolicy.timeout_ms}ms`
+              : (result.error?.message || `agent command exited with status ${result.status}`))
+            : `${evaluation.reason_code}: ${evaluation.findings.join('; ')}`;
         failLeaseTask(db, assignment.lease_id, failureReason);
         retry = scheduleTaskRetry(db, {
           pipelineId,
@@ -1236,7 +1267,7 @@ function runPipelineIteration(
       logAuditEvent(db, {
         eventType: 'pipeline_task_executed',
         status: ok ? 'allowed' : 'denied',
-        reasonCode: ok ? null : (timedOut ? 'task_execution_timeout' : 'agent_command_failed'),
+        reasonCode,
         worktree: assignment.worktree,
         taskId: assignment.task_id,
         leaseId: assignment.lease_id,

package/src/core/planner.js

@@ -9,7 +9,7 @@ const DOMAIN_RULES = [
   { key: 'api', regex: /\b(api|endpoint|route|graphql|rest|handler)\b/i, source: ['src/api/**', 'app/api/**', 'server/api/**', 'routes/**'] },
   { key: 'schema', regex: /\b(schema|migration|database|db|sql|prisma)\b/i, source: ['db/**', 'database/**', 'migrations/**', 'prisma/**', 'schema/**', 'src/db/**'] },
   { key: 'config', regex: /\b(config|configuration|env|feature flag|settings?)\b/i, source: ['config/**', '.github/**', '.switchman/**', 'src/config/**'] },
-  { key: 'payments', regex: /\b(payment|billing|invoice|checkout|subscription|stripe)\b/i, source: ['src/payments/**', 'app/payments/**', 'lib/payments/**', 'server/payments/**'] },
+  { key: 'payments', regex: /\b(payments?|billing|invoice|checkout|subscription|stripe)\b/i, source: ['src/payments/**', 'app/payments/**', 'lib/payments/**', 'server/payments/**'] },
   { key: 'ui', regex: /\b(ui|ux|frontend|component|screen|page|layout)\b/i, source: ['src/components/**', 'src/ui/**', 'app/**', 'client/**'] },
   { key: 'infra', regex: /\b(deploy|infra|infrastructure|build|pipeline|docker|kubernetes|terraform)\b/i, source: ['infra/**', '.github/**', 'docker/**', 'scripts/**'] },
   { key: 'docs', regex: /\b(docs?|readme|documentation|integration notes)\b/i, source: ['docs/**', 'README.md'] },
@@ -154,10 +154,8 @@ function deriveSubtaskTitles(title, description) {
   const text = `${title}\n${description || ''}`.toLowerCase();
   const subtasks = [];
   const domains = detectDomains(text);
-  const highRisk = /\b(auth|payment|schema|migration|security|permission|billing)\b/.test(text);
-
-  const docsOnly = /\b(docs?|readme|documentation)\b/.test(text)
-    && !/\b(api|auth|bug|feature|fix|refactor|schema|migration|config|build|test)\b/.test(text);
+  const highRisk = /\b(auth|payments?|schema|migration|security|permission|billing)\b/.test(text);
+  const docsOnly = isDocsOnlyRequest(text);
 
   if (docsOnly) {
     return [`Update docs for: ${title}`];
@@ -180,8 +178,14 @@ function deriveSubtaskTitles(title, description) {
   return subtasks;
 }
 
+function isDocsOnlyRequest(text) {
+  return /\b(docs?|readme|documentation)\b/.test(text)
+    && !/\b(auth|bug|feature|fix|refactor|schema|migration|config|build|test|implement|route|handler|endpoint|model)\b/.test(text);
+}
+
 function inferRiskLevel(text) {
-  if (/\b(auth|payment|schema|migration|security|permission|billing)\b/.test(text)) return 'high';
+  if (isDocsOnlyRequest(text)) return 'low';
+  if (/\b(auth|payments?|schema|migration|security|permission|billing)\b/.test(text)) return 'high';
   if (/\b(api|config|deploy|build|infra)\b/.test(text)) return 'medium';
   return 'low';
 }

package/src/core/policy.js

@@ -4,7 +4,7 @@ import { dirname, join } from 'path';
 export const DEFAULT_LEASE_POLICY = {
   heartbeat_interval_seconds: 60,
   stale_after_minutes: 15,
-  reap_on_status_check: false,
+  reap_on_status_check: true,
   requeue_task_on_reap: true,
 };
 

package/src/core/queue.js

@@ -30,7 +30,7 @@ function computeQueueRetryBackoff(item) {
   };
 }
 
-function describeQueueError(err) {
+export function describeQueueError(err) {
   const message = String(err?.stderr || err?.message || err || '').trim();
   if (/conflict/i.test(message)) {
     return {
@@ -50,6 +50,15 @@ function describeQueueError(err) {
     };
   }
 
+  if (/untracked working tree files would be overwritten by merge/i.test(message)) {
+    return {
+      code: 'untracked_worktree_files',
+      summary: message || 'Untracked local files would be overwritten by merge.',
+      nextAction: 'Remove or ignore the untracked files in the target worktree, then run `switchman queue retry <itemId>`. Project-local MCP files should be excluded via `.git/info/exclude` after `switchman setup`.',
+      retryable: true,
+    };
+  }
+
   return {
     code: 'merge_failed',
     summary: message || 'Merge queue item failed.',
@@ -87,7 +96,7 @@ function scheduleRetryOrBlock(db, item, failure) {
   };
 }
 
-async function evaluateQueueRepoGate(db, repoRoot) {
+export async function evaluateQueueRepoGate(db, repoRoot) {
   const report = await scanAllWorktrees(db, repoRoot);
   const aiGate = await runAiMergeGate(db, repoRoot);
   const ok = report.conflicts.length === 0

package/src/core/sync.js

@@ -0,0 +1,216 @@
+/**
+ * switchman cloud sync module
+ * Syncs coordination state to Supabase for Pro team users.
+ *
+ * Only runs when:
+ *   1. The user has a valid Pro licence
+ *   2. The user is a member of a team
+ *   3. Network is available
+ *
+ * Never throws — all sync operations are best-effort.
+ * Local SQLite remains the source of truth.
+ */
+
+import { readCredentials } from './licence.js';
+
+// ─── Config ───────────────────────────────────────────────────────────────────
+
+const SUPABASE_URL  = process.env.SWITCHMAN_SUPABASE_URL
+  ?? 'https://afilbolhlkiingnsupgr.supabase.co';
+
+const SUPABASE_ANON = process.env.SWITCHMAN_SUPABASE_ANON
+  ?? 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFmaWxib2xobGtpaW5nbnN1cGdyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzM1OTIzOTIsImV4cCI6MjA4OTE2ODM5Mn0.8TBfHfRB0vEyKPMWBd6i1DNwx1nS9UqprIAsJf35n88';
+
+const SYNC_TIMEOUT_MS = 3000;
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function getHeaders(accessToken) {
+  return {
+    'Content-Type': 'application/json',
+    'apikey': SUPABASE_ANON,
+    'Authorization': `Bearer ${accessToken}`,
+  };
+}
+
+async function fetchWithTimeout(url, options, timeoutMs = SYNC_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    return res;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── Team resolution ──────────────────────────────────────────────────────────
+
+/**
+ * Get the team ID for the current user.
+ * Returns null if not in a team or on error.
+ */
+async function getTeamId(accessToken, userId) {
+  try {
+    const res = await fetchWithTimeout(
+      `${SUPABASE_URL}/rest/v1/team_members?user_id=eq.${userId}&select=team_id&limit=1`,
+      { headers: getHeaders(accessToken) }
+    );
+    if (!res.ok) return null;
+    const rows = await res.json();
+    return rows?.[0]?.team_id ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// ─── Push ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Push a state change event to Supabase.
+ * Called after any state-changing command.
+ *
+ * eventType: 'task_added' | 'task_done' | 'task_failed' | 'lease_acquired' |
+ *            'claim_added' | 'claim_released' | 'status_ping'
+ * payload: object with relevant fields
+ */
+export async function pushSyncEvent(eventType, payload, { worktree = null } = {}) {
+  try {
+    const creds = readCredentials();
+    if (!creds?.access_token || !creds?.user_id) return;
+
+    const teamId = await getTeamId(creds.access_token, creds.user_id);
+    if (!teamId) return; // Not in a team — no sync needed
+
+    const resolvedWorktree = worktree
+      ?? process.cwd().split('/').pop()
+      ?? 'unknown';
+
+    await fetchWithTimeout(
+      `${SUPABASE_URL}/rest/v1/sync_state`,
+      {
+        method: 'POST',
+        headers: {
+          ...getHeaders(creds.access_token),
+          'Prefer': 'return=minimal',
+        },
+        body: JSON.stringify({
+          team_id: teamId,
+          user_id: creds.user_id,
+          worktree: resolvedWorktree,
+          event_type: eventType,
+          payload: {
+            ...payload,
+            email: creds.email ?? null,
+            synced_at: new Date().toISOString(),
+          },
+        }),
+      }
+    );
+  } catch {
+    // Best effort — never fail the local operation
+  }
+}
+
+// ─── Pull ─────────────────────────────────────────────────────────────────────
+
+/**
+ * Pull recent team sync events from Supabase.
+ * Returns an array of events or empty array on error.
+ * Used by `switchman status` to show team-wide activity.
+ */
+export async function pullTeamState() {
+  try {
+    const creds = readCredentials();
+    if (!creds?.access_token || !creds?.user_id) return [];
+
+    const teamId = await getTeamId(creds.access_token, creds.user_id);
+    if (!teamId) return [];
+
+    // Pull last 5 minutes of events from all team members
+    const since = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+
+    const res = await fetchWithTimeout(
+      `${SUPABASE_URL}/rest/v1/sync_state` +
+      `?team_id=eq.${teamId}` +
+      `&created_at=gte.${since}` +
+      `&order=created_at.desc` +
+      `&limit=50`,
+      { headers: getHeaders(creds.access_token) }
+    );
+
+    if (!res.ok) return [];
+    return await res.json();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Pull active team members (those with events in the last 15 minutes).
+ * Returns array of { email, worktree, event_type, payload, created_at }
+ */
+export async function pullActiveTeamMembers() {
+  try {
+    const creds = readCredentials();
+    if (!creds?.access_token || !creds?.user_id) return [];
+
+    const teamId = await getTeamId(creds.access_token, creds.user_id);
+    if (!teamId) return [];
+
+    const since = new Date(Date.now() - 15 * 60 * 1000).toISOString();
+
+    const res = await fetchWithTimeout(
+      `${SUPABASE_URL}/rest/v1/sync_state` +
+      `?team_id=eq.${teamId}` +
+      `&created_at=gte.${since}` +
+      `&order=created_at.desc` +
+      `&limit=100`,
+      { headers: getHeaders(creds.access_token) }
+    );
+
+    if (!res.ok) return [];
+    const events = await res.json();
+
+    // Deduplicate — keep most recent event per user+worktree
+    const seen = new Map();
+    for (const event of events) {
+      const key = `${event.user_id}:${event.worktree}`;
+      if (!seen.has(key)) {
+        seen.set(key, event);
+      }
+    }
+
+    return [...seen.values()];
+  } catch {
+    return [];
+  }
+}
+
+// ─── Cleanup ──────────────────────────────────────────────────────────────────
+
+/**
+ * Delete sync events older than the configured retention window for this user.
+ * Called occasionally to keep the table tidy.
+ * Best effort — never fails.
+ */
+export async function cleanupOldSyncEvents({ retentionDays = 7 } = {}) {
+  try {
+    const creds = readCredentials();
+    if (!creds?.access_token || !creds?.user_id) return;
+
+    const cutoff = new Date(Date.now() - Math.max(1, Number.parseInt(retentionDays, 10) || 7) * 24 * 60 * 60 * 1000).toISOString();
+
+    await fetchWithTimeout(
+      `${SUPABASE_URL}/rest/v1/sync_state` +
+      `?user_id=eq.${creds.user_id}` +
+      `&created_at=lt.${cutoff}`,
+      {
+        method: 'DELETE',
+        headers: getHeaders(creds.access_token),
+      }
+    );
+  } catch {
+    // Best effort
+  }
+}

package/src/mcp/server.js

@@ -26,7 +26,9 @@ import {
   createTask,
   startTaskLease,
   completeTask,
+  completeLeaseTask,
   failTask,
+  failLeaseTask,
   listTasks,
   getNextPendingTask,
   listLeases,
@@ -631,11 +633,16 @@ Returns JSON:
         db.close();
         return toolError(`Task ${task_id} is active under lease ${activeLease.id}, not ${lease_id}.`);
       }
-      completeTask(db, task_id);
-      releaseFileClaims(db, task_id);
+      const effectiveLeaseId = activeLease?.id ?? lease_id ?? null;
+      if (effectiveLeaseId) {
+        completeLeaseTask(db, effectiveLeaseId);
+      } else {
+        completeTask(db, task_id);
+        releaseFileClaims(db, task_id);
+      }
       db.close();
 
-      const result = { task_id, lease_id: activeLease?.id ?? lease_id ?? null, status: 'done', files_released: true };
+      const result = { task_id, lease_id: effectiveLeaseId, status: 'done', files_released: true };
       return toolOk(JSON.stringify(result, null, 2), result);
     } catch (err) {
       return toolError(err.message);
@@ -686,11 +693,16 @@ Returns JSON:
         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);
+      const effectiveLeaseId = activeLease?.id ?? lease_id ?? null;
+      if (effectiveLeaseId) {
+        failLeaseTask(db, effectiveLeaseId, reason);
+      } else {
+        failTask(db, task_id, reason);
+        releaseFileClaims(db, task_id);
+      }
       db.close();
 
-      const result = { task_id, lease_id: activeLease?.id ?? lease_id ?? null, status: 'failed', reason, files_released: true };
+      const result = { task_id, lease_id: effectiveLeaseId, status: 'failed', reason, files_released: true };
       return toolOk(JSON.stringify(result, null, 2), result);
     } catch (err) {
       return toolError(err.message);