atris 3.78.0 → 3.80.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
@@ -3106,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
@@ -3118,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);
@@ -3133,6 +3174,7 @@ function withBusyRetry(fn, attempts = 8) {
 module.exports = {
   open,
   withBusyRetry,
+  isBusyError,
   close,
   getDbPath,
   workspaceRoot,
@@ -3144,6 +3186,7 @@ module.exports = {
   listTasks,
   listTasksCached,
   rowInWorkspace,
+  lookUpLinkedWorktrees,
   claimTask,
   setLease,
   renewLease,

package/lib/task-decision.js

@@ -5,6 +5,8 @@
 // marker is needs-human (CLI-879); decision is the same hold under a clearer
 // name. Autonomous pickers must refuse these; list renderers must show them.
 
+const { decisionChoiceText } = require('./task-explanation');
+
 const DECISION_HOLD_TAGS = new Set([
   'needs-human',
   'needshuman',
@@ -41,10 +43,74 @@ function decisionMarkerFor(task) {
   return isDecisionTask(task) ? DECISION_MARKER : '';
 }
 
+function decisionRefFor(task) {
+  if (!task || typeof task !== 'object') return 'TASK';
+  const ref = task.display_id || task.legacy_ref || task.id || '';
+  const text = String(ref || '').trim();
+  if (!text) return 'TASK';
+  if (task.display_id || task.legacy_ref) return text;
+  return text.replace(/[^a-zA-Z0-9]/g, '').toUpperCase().slice(0, 8) || 'TASK';
+}
+
+function decisionShowCommand(task) {
+  return `atris task show ${decisionRefFor(task)}`;
+}
+
+function summarizeDecisionTask(task) {
+  const ref = decisionRefFor(task);
+  const title = String((task && task.title) || '').replace(/\s+/g, ' ').trim();
+  const choice = decisionChoiceText(task);
+  const command = `atris task show ${ref}`;
+  return {
+    id: (task && task.id) || null,
+    task_id: (task && task.id) || null,
+    ref,
+    display_id: (task && task.display_id) || ref,
+    title,
+    choice,
+    command,
+    show_command: command,
+  };
+}
+
+function summarizeSkippedDecisions(tasks = []) {
+  const list = (Array.isArray(tasks) ? tasks : [])
+    .filter(Boolean)
+    .map(summarizeDecisionTask);
+  const first = list[0] || null;
+  return {
+    reason: DECISION_REFUSE_REASON,
+    skipped_decision_count: list.length,
+    skipped_decision_refs: list.map((item) => item.ref),
+    skipped_decisions: list,
+    decisions: list,
+    choice: first ? first.choice : null,
+    command: first ? first.command : null,
+    show_command: first ? first.command : null,
+    next_command: first ? first.command : null,
+  };
+}
+
+function formatDecisionRefusalLines(tasks = []) {
+  const summary = summarizeSkippedDecisions(tasks);
+  const lines = [DECISION_REFUSE_REASON];
+  for (const item of summary.skipped_decisions) {
+    lines.push(`  ${item.ref}: ${item.title}`);
+    lines.push(`  choice: ${item.choice}`);
+    lines.push(`  show: ${item.command}`);
+  }
+  if (summary.command) {
+    lines.push(`next: ${summary.command}`);
+  }
+  return lines;
+}
+
 module.exports = {
   DECISION_REFUSE_REASON,
   taskTagTokens,
   isDecisionHoldTag,
   isDecisionTask,
   decisionMarkerFor,
+  summarizeSkippedDecisions,
+  formatDecisionRefusalLines,
 };

package/lib/task-explanation.js

@@ -213,6 +213,25 @@ function taskApprovalControls({
   };
 }
 
+function decisionChoiceText(task) {
+  const metadata = task && task.metadata && typeof task.metadata === 'object' ? task.metadata : {};
+  const explicitChoice = cleanText(
+    (task && task.choice)
+    || metadata.choice
+    || metadata.decision
+    || metadata.question
+  );
+  if (explicitChoice) return endSentence(plainText(explicitChoice));
+  const explicit = explicitExplanationFields(metadata);
+  if (explicit.what_changes) return endSentence(plainText(explicit.what_changes));
+  if (explicit.why_it_matters) return endSentence(plainText(explicit.why_it_matters));
+  const goal = cleanText(explanationGoalText(task));
+  if (goal) return endSentence(plainText(goal));
+  const title = cleanText(task && task.title);
+  if (title) return endSentence(plainText(title));
+  return 'Decide whether to approve this work, revise it, or remove the decision hold.';
+}
+
 function approvalLines(approval, { indent = '' } = {}) {
   const lines = [`${indent}${approval.question}`];
   if (approval.approve.enabled) lines.push(`${indent}Approve: ${approval.approve.command}`);
@@ -228,6 +247,7 @@ module.exports = {
   explicitDoneLooksLike,
   plainText,
   taskExplanation,
+  decisionChoiceText,
   explanationFieldsFromInput,
   explanationLines,
   explanationMarkdownLines,

package/lib/yes-lock.js

@@ -593,7 +593,7 @@ const ATRIS_INTERNAL = new Set([
   'version', 'help', 'next', 'atris', 'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'learn', 'lesson', 'taste', 'teach',
   'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'watch', 'live', 'align', 'terminal', 'computer', 'diff', 'youtube', 'x-search',
   'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'campaign', 'agents', 'probe', 'worktree', 'caretaker', 'aeo', 'slop', 'voice', 'strings', 'write',
-  'security-review', 'secure', 'theme', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'recap', 'report', 'clarity', 'interview', 'moves', 'unknowns', 'avail',
+  'security-review', 'secure', 'sentinel', 'theme', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'recap', 'report', 'clarity', 'interview', 'moves', 'unknowns', 'avail',
   'scoreboard', 'sync-checkout', 'zen', 'ci', 'balance', 'usage', 'agent-client', 'transactions', 'hires', 'design', 'mcp', 'integrations', 'setup', 'clean-workspace', 'cw',
   'browse', 'sleep', 'wake', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'engine',
   'engines', 'link', 'playbook', 'brief', 'inbox', 'friends', 'rsi',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.78.0",
+  "version": "3.80.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",