atris 3.77.0 → 3.79.0

package/lib/task-db.js

@@ -197,24 +197,39 @@ function getDbPath() {
   return process.env.ATRIS_TASKS_DB || path.join(atrisHome(), 'tasks.db');
 }
 
-function open(dbPath) {
+// How many times each setup statement of a short-wait connection is tried while another process holds
+// the write lock: with the connection's own busy wait left at nothing, about a second in all.
+const SHORT_WAIT_TRIES = 7;
+
+// shortWait is for a caller that must not hang behind other writers (the automatic held-job sweep). It
+// gets a connection of its own, never the cached one, that the caller closes. The connection's own busy
+// wait stays at nothing, so a store that stays locked is given up on after about a second, with the busy
+// error (see isBusyError) for the caller to tell apart, and the handle is closed.
+function open(dbPath, { shortWait = false } = {}) {
   const target = dbPath || getDbPath();
-  if (_cachedDb && _cachedPath === target) return _cachedDb;
+  if (!shortWait && _cachedDb && _cachedPath === target) return _cachedDb;
   const dir = path.dirname(target);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   const db = new DatabaseSync(target);
-  // Concurrency: WAL gives readers + one writer concurrency; busy_timeout
-  // makes contended writers wait instead of returning SQLITE_BUSY at the
-  // C library level. We additionally wrap the setup PRAGMAs + DDL in our
-  // own retry, under heavy spawn-storm contention, node:sqlite leaks
-  // SQLITE_BUSY past the busy_timeout for `db.exec()` calls.
-  withBusyRetry(() => db.exec('PRAGMA journal_mode = WAL'));
-  withBusyRetry(() => db.exec('PRAGMA busy_timeout = 30000'));
-  withBusyRetry(() => db.exec('PRAGMA foreign_keys = ON'));
-  withBusyRetry(() => db.exec(SCHEMA));
-  // Schema version. Bump at every additive migration.
-  // Future migrations read this and apply diffs idempotently.
-  withBusyRetry(() => db.exec('PRAGMA user_version = 2'));
+  const tries = shortWait ? SHORT_WAIT_TRIES : undefined;
+  try {
+    // Concurrency: WAL gives readers + one writer concurrency; busy_timeout
+    // makes contended writers wait instead of returning SQLITE_BUSY at the
+    // C library level. We additionally wrap the setup PRAGMAs + DDL in our
+    // own retry, under heavy spawn-storm contention, node:sqlite leaks
+    // SQLITE_BUSY past the busy_timeout for `db.exec()` calls.
+    withBusyRetry(() => db.exec('PRAGMA journal_mode = WAL'), tries);
+    if (!shortWait) withBusyRetry(() => db.exec('PRAGMA busy_timeout = 30000'));
+    withBusyRetry(() => db.exec('PRAGMA foreign_keys = ON'), tries);
+    withBusyRetry(() => db.exec(SCHEMA), tries);
+    // Schema version. Bump at every additive migration.
+    // Future migrations read this and apply diffs idempotently.
+    withBusyRetry(() => db.exec('PRAGMA user_version = 2'), tries);
+  } catch (err) {
+    try { db.close(); } catch (_) {}
+    throw err;
+  }
+  if (shortWait) return db;
   _cachedDb = db;
   _cachedPath = target;
   return db;
@@ -476,21 +491,43 @@ function findUnfinishedTaskByTitle(db, { workspaceRoot: ws, title }) {
 // A main checkout's view also covers its linked git worktrees, whose tasks keep
 // the worktree as workspace_root so checks run where the work lives. Only a
 // main checkout with linked worktrees spawns git; any error means exact match.
+// A git that does not answer in time is ended outright (SIGKILL, because the
+// polite stop can be ignored), so no git can hold a command for good.
+const LINKED_WORKTREE_LOOKUP_MS = 5000;
 const linkedWorktreeCache = new Map();
-function linkedWorktreeRoots(ws) {
+
+// { roots, failed }: the checkouts linked to ws, and whether git could not say (it
+// did not answer within timeoutMs, could not be run, or exited with an error), in
+// which case roots is empty. The task list ignores the failure and shows the
+// workspace alone; a caller that must know asks here. A failure is remembered for the
+// process, except one under a limit the caller chose that is shorter than the usual
+// one: the task list that comes next still gets its own full try.
+function lookUpLinkedWorktrees(ws, { timeoutMs = LINKED_WORKTREE_LOOKUP_MS } = {}) {
   if (linkedWorktreeCache.has(ws)) return linkedWorktreeCache.get(ws);
-  let roots = [];
+  let looked = { roots: [], failed: false };
   try {
     if (fs.existsSync(path.join(ws, '.git', 'worktrees'))) {
+      // A limit of 0 would mean no limit at all.
+      if (!(timeoutMs > 0)) throw new Error('no time left to ask git');
       const out = require('child_process').execFileSync('git', ['worktree', 'list', '--porcelain'],
-        { cwd: ws, encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] });
-      roots = out.split('\n').filter(l => l.startsWith('worktree '))
-        .map(l => { const p = l.slice(9); try { return fs.realpathSync(p); } catch { return p; } })
-        .filter(p => p !== ws);
+        { cwd: ws, encoding: 'utf8', timeout: timeoutMs, killSignal: 'SIGKILL', stdio: ['ignore', 'pipe', 'ignore'] });
+      looked = {
+        roots: out.split('\n').filter(l => l.startsWith('worktree '))
+          .map(l => { const p = l.slice(9); try { return fs.realpathSync(p); } catch { return p; } })
+          .filter(p => p !== ws),
+        failed: false,
+      };
     }
-  } catch { roots = []; }
-  linkedWorktreeCache.set(ws, roots);
-  return roots;
+  } catch {
+    looked = { roots: [], failed: true };
+    if (timeoutMs < LINKED_WORKTREE_LOOKUP_MS) return looked;
+  }
+  linkedWorktreeCache.set(ws, looked);
+  return looked;
+}
+
+function linkedWorktreeRoots(ws) {
+  return lookUpLinkedWorktrees(ws).roots;
 }
 
 // The workspaces a workspace's task listing covers: the workspace itself and, for a main
@@ -645,13 +682,34 @@ const NAMED_CLAIM_SQL = `AND (? IS NULL OR EXISTS (
      AND (tasks.claimed_at IS NULL OR e.created_at >= tasks.claimed_at)
      AND e.version = (SELECT MAX(version) FROM task_events WHERE task_id = tasks.id AND event_type = 'claimed')))`;
 
+// The job as it stands when a claim is made: its title and tags, saved on the claim itself. The builder picker
+// (lib/builder-pick.js) gives a play the lane its job was in when the claim was made, and tagging or renaming a
+// finished job later must not change that. Every way of claiming a job writes it (claimTask, and the claim that
+// starting work on an open or unowned job makes); a claim made before this existed has none and is never rebuilt
+// from the job's history.
+function jobAtClaim(row, metadata) {
+  const meta = metadata && typeof metadata === 'object' ? metadata : {};
+  return {
+    title: String(row.title == null ? '' : row.title),
+    tag: row.tag || null,
+    tags: Array.isArray(meta.tags) ? meta.tags : [],
+    todo_tags: Array.isArray(meta.todo_tags) ? meta.todo_tags : [],
+  };
+}
+
 // Atomic claim. Returns { claimed: true, row, event } only if THIS call won the row; event is the claimed event
 // this claim wrote, the one name for it (see latestClaim). Race-safe via single UPDATE with WHERE status='open'
 // guard. SQLite serializes writes; busy_timeout absorbs contention. Caller must check `.claimed`.
 //
 // The row and its claimed event are written in one transaction. Before, the row was claimed first and the event
 // followed a git call later, and in that gap a late release naming the claim before could pass for the new one.
-function claimTask(db, { id, claimedBy, leaseMinutes, leasePid }) {
+//
+// refuseIf is a check the caller makes on the job as it stands when the claim is made: it is asked with the open job
+// (as getTask shows it) inside the same transaction, with the write lock held, so nothing can change the job between
+// the look and the claim. It answers with a reason to refuse, and the job is then not claimed and nothing is written
+// ({ claimed: false, reason }); an empty answer lets the claim go on. A job that is not open is not asked about, and
+// answers as it always did. A check that throws takes the claim with it: nothing is claimed.
+function claimTask(db, { id, claimedBy, leaseMinutes, leasePid, refuseIf = null }) {
   if (!id) throw new Error('id required');
   if (!claimedBy) throw new Error('claimedBy required');
   const now = Date.now();
@@ -672,6 +730,11 @@ function claimTask(db, { id, claimedBy, leaseMinutes, leasePid }) {
   `);
   const lease = leaseMinutes == null ? null : JSON.stringify({ until: new Date(now + leaseMinutes * 60000).toISOString(), minutes: leaseMinutes, holder: claimedBy, pid: leasePid });
   const won = inWriteTransaction(db, () => {
+    if (refuseIf) {
+      const current = getTask(db, id);
+      const why = current && current.status === 'open' ? refuseIf(current) : '';
+      if (why) return { refused: String(why) };
+    }
     const result = withBusyRetry(() => stmt.run(claimedBy, now, now, lease, lease, id));
     if (result.changes !== 1) return null;
     let row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
@@ -693,10 +756,16 @@ function claimTask(db, { id, claimedBy, leaseMinutes, leasePid }) {
       workspaceRoot: row.workspace_root,
       actor: claimedBy,
       eventType: 'claimed',
-      payload: { claimed_by: claimedBy, ...(startCommit ? { start_commit: startCommit } : {}) },
+      payload: {
+        claimed_by: claimedBy,
+        ...(startCommit ? { start_commit: startCommit } : {}),
+        // Written in this transaction, so a claim never exists without it.
+        job_at_claim: jobAtClaim(row, claimedMetadata),
+      },
     });
     return { row, event };
   });
+  if (won && won.refused) return { claimed: false, reason: won.refused };
   if (won) {
     const enriched = { ...won.row, metadata: won.row.metadata ? safeJSON(won.row.metadata) : null };
     // The work log is a note for people, written once the claim is saved. A note that cannot be written must not
@@ -2300,7 +2369,7 @@ function stageTaskSteps(db, {
       workspaceRoot: updated.workspace_root,
       actor: claimedWorker,
       eventType: 'claimed',
-      payload: { claimed_by: claimedWorker },
+      payload: { claimed_by: claimedWorker, job_at_claim: jobAtClaim(updated, updated.metadata) },
     });
   }
   const event = appendTaskEvent(db, {
@@ -3074,6 +3143,13 @@ function safeJSON(s) {
   try { return JSON.parse(s); } catch { return null; }
 }
 
+// Whether an error is the store being busy: another process holds the write lock.
+function isBusyError(e) {
+  const msg = String(e && e.message || '');
+  const code = e && (e.code || e.errcode);
+  return /SQLITE_BUSY|database is locked/i.test(msg) || code === 'SQLITE_BUSY' || code === 5;
+}
+
 // Wrap a write op so SQLITE_BUSY (concurrent writers from other processes)
 // retries with exponential backoff. busy_timeout pragma alone leaks busy
 // errors under spawn-storm contention with node:sqlite (~3% raw lock rate
@@ -3086,10 +3162,7 @@ function withBusyRetry(fn, attempts = 8) {
     try { return fn(); }
     catch (e) {
       lastErr = e;
-      const msg = String(e && e.message || '');
-      const code = e && (e.code || e.errcode);
-      const busy = /SQLITE_BUSY|database is locked/i.test(msg) || code === 'SQLITE_BUSY' || code === 5;
-      if (!busy) throw e;
+      if (!isBusyError(e)) throw e;
       // Sleep synchronously, node:sqlite is sync; matches the rest of the API
       sleepSync(delay + Math.floor(Math.random() * delay));
       delay = Math.min(delay * 2, 500);
@@ -3101,6 +3174,7 @@ function withBusyRetry(fn, attempts = 8) {
 module.exports = {
   open,
   withBusyRetry,
+  isBusyError,
   close,
   getDbPath,
   workspaceRoot,
@@ -3112,6 +3186,7 @@ module.exports = {
   listTasks,
   listTasksCached,
   rowInWorkspace,
+  lookUpLinkedWorktrees,
   claimTask,
   setLease,
   renewLease,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.77.0",
+  "version": "3.79.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",