atris 3.32.0 → 3.33.3

package/commands/task.js

@@ -16,6 +16,14 @@ const {
   resolveFunctionalOwner: resolveFunctionalTaskOwner,
 } = require('../lib/functional-owner');
 const { operatorReady, hasAgentJargon } = require('./autoland');
+const {
+  TASK_INSPECT_FIELDS,
+  readFieldsFlag,
+  stripInspectArgs,
+  validateFields,
+  inspectTextLines,
+  buildInspectPayload,
+} = require('../lib/inspect-fields');
 
 const DEFAULT_OWNER = process.env.ATRIS_AGENT_ID
   || process.env.USER
@@ -105,7 +113,8 @@ atris task - durable local task state (SQLite, gitignored)
 
   atris task                              Show the task desk
   atris task new "<title>"                Create a task
-  atris task next [--create-next]         Claim/show next open task; optionally create the generated Endgame fallback
+  atris task next [--tag <tag>] [--create-next]
+                                           Claim/show next open task; optionally create the generated Endgame fallback
   atris task continue-work <id>           Create/reuse a certified Review follow-up task
   atris task say <id> "<message>"         Add context to a task
   atris task chat <id> "<message>" [--goal "..."]  Refine a task chat + working goal
@@ -139,6 +148,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task day [--json]                  Show today's owner-grouped task list
   atris task list [--all] [--status <s>]   List tasks (default: this workspace)
   atris task claim <id> [--as <owner>]     Atomic claim
+  atris task release <id> [--as <owner>]   Release your own mistaken claim back to open
   atris task capabilities [--json]         Read-only task CLI/API capability contract
   atris task capabilities-check [--json]   Verify task capability contract conformance
   atris task review-lane-drain [--json]    Pick next safe Review-lane agent action
@@ -154,6 +164,8 @@ atris task - durable local task state (SQLite, gitignored)
                                            review-state lanes: needs-agent, continue-work, human-accept-waiting, certified
   atris task note <id> "<message>"         Append dialogue/context to a task
   atris task show <id> [--json]            Show a task card + dialogue
+  atris task inspect <id> --fields review,status,title [--json]
+                                           Field-selectable task state (review metadata, status, title, owner, tag)
   atris task page <id> [--json]            Show the one-task page contract
   atris task step <id> [--json]            Refine chat, then advance one safe Plan/Do/Review step
   atris task done <id> --proof "..."       Mark complete with proof
@@ -1105,6 +1117,50 @@ function taskReviewSummary(task) {
   return reviewSummaryWithVerificationChat(task, review);
 }
 
+function taskReviewInspectMetadata(task) {
+  const review = task.review || taskReviewSummary(task);
+  if (!review) return null;
+  return {
+    approval_status: review.approval_status || null,
+    agent_certified: review.agent_certified === true,
+    agent_review_pass_count: review.agent_review_pass_count || null,
+    agent_certification_policy: review.agent_certification_policy || null,
+    summary: review.summary || null,
+    proof: review.proof || null,
+    lesson: review.lesson || null,
+    next_task: review.next_task || null,
+    human_revision_count: review.human_revision_count || null,
+    human_revision_note: review.human_revision_note || null,
+    reward: review.reward ?? null,
+  };
+}
+
+function taskInspectFieldValues(task, fields) {
+  const values = {};
+  for (const field of fields) {
+    switch (field) {
+      case 'status':
+        values.status = task.status || null;
+        break;
+      case 'title':
+        values.title = task.title || null;
+        break;
+      case 'claimed_by':
+        values.claimed_by = task.claimed_by || null;
+        break;
+      case 'tag':
+        values.tag = task.tag || null;
+        break;
+      case 'review':
+        values.review = taskReviewInspectMetadata(task);
+        break;
+      default:
+        break;
+    }
+  }
+  return values;
+}
+
 function reviewSummaryWithVerificationChat(task, review) {
   if (!review || task.status !== 'review' || review.approval_status !== 'pending') return review;
   const verifierTask = taskWithReviewEvidence(task, {
@@ -3204,6 +3260,11 @@ function formatTaskQueueScope(scope = {}) {
     .join(' ');
 }
 
+function noOpenTasksMessage(scope = {}) {
+  const scopeText = formatTaskQueueScope(scope);
+  return scopeText ? `No open tasks for ${scopeText}.` : 'No open tasks.';
+}
+
 function taskQueueContract(projection, { reviewer = 'codex-review', limit = 8, scope = {}, hasExistingReviewFollowUp = null, hasPendingReviewChat = null, excludeTaskIds = null } = {}) {
   const normalizedScope = normalizeTaskQueueScope(scope);
   const tasks = filterTasksByScope(sortTasksNewestFirst(projection.tasks || []), normalizedScope, { hasExistingReviewFollowUp });
@@ -5175,20 +5236,24 @@ function cmdHome(args) {
 function cmdList(args) {
   const all = hasFlag(args, '--all');
   const status = flag(args, '--status');
+  const scope = taskQueueScopeFromArgs(args);
+  const scoped = !taskQueueScopeIsEmpty(scope);
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const rows = taskDb.listTasks(db, {
+  const rawRows = taskDb.listTasks(db, {
     workspaceRoot: all ? null : taskDb.workspaceRoot(),
     status: typeof status === 'string' ? status : null,
-    limit: 200,
+    limit: scoped ? null : 200,
   });
+  const rows = filterTasksByScope(rawRows, scope);
   const displayRows = taskDb.withTaskDisplayRefs(rows, workspaceRefRows(taskDb, db, all));
   if (wantsJson(args)) {
-    printJson({ ok: true, action: 'list', tasks: displayRows });
+    printJson({ ok: true, action: 'list', scope: normalizeTaskQueueScope(scope), tasks: displayRows });
     return;
   }
   if (rows.length === 0) {
-    console.log('(no tasks)');
+    const scopeText = formatTaskQueueScope(scope);
+    console.log(scopeText ? `(no tasks for ${scopeText})` : '(no tasks)');
     return;
   }
   for (const r of displayRows) {
@@ -5224,19 +5289,68 @@ function cmdClaim(args) {
     }
     console.log(`claimed ${taskRef(compactTaskFromProjection(projection, taskId))} as ${owner}`);
   } else {
+    const recoveryCommand = result.reason === 'already_claimed' && result.claimed_by
+      ? `atris task release ${id} --as ${result.claimed_by}`
+      : null;
     if (wantsJson(args)) {
       printJson({
         ok: false,
         command: 'atris task claim',
         reason: result.reason,
         claimed_by: result.claimed_by || null,
+        recovery_command: recoveryCommand,
         detail: `claim failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`,
       });
       process.exit(1);
     }
     console.error(`claim failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`);
+    if (recoveryCommand) console.error(`Recovery: ${recoveryCommand}`);
+    process.exit(1);
+  }
+}
+
+function cmdRelease(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) {
+    failTask('atris task release', 'missing_id', 'id required');
+  }
+  const owner = flag(args, '--as') || DEFAULT_OWNER;
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task release');
+  const result = taskDb.releaseTask(db, { id: taskId, actor: String(owner) });
+  if (result.released) {
+    const { projection, outPath } = writeDefaultProjection(taskDb, db);
+    const task = compactTaskFromProjection(projection, taskId);
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'released',
+        task_id: taskId,
+        owner: String(owner),
+        projection_path: outPath,
+        task,
+        event_version: result.event && result.event.version || null,
+      });
+      return;
+    }
+    console.log(`released ${taskRef(task)} from ${owner}`);
+    console.log(`Next: atris task next --as ${owner}`);
+    return;
+  }
+  if (wantsJson(args)) {
+    printJson({
+      ok: false,
+      command: 'atris task release',
+      reason: result.reason,
+      claimed_by: result.claimed_by || null,
+      detail: `release failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`,
+    });
     process.exit(1);
   }
+  console.error(`release failed: ${result.reason}${result.claimed_by ? ` (held by ${result.claimed_by})` : ''}`);
+  process.exit(1);
 }
 
 function liveTaskWithTitle(tasks, title) {
@@ -5342,14 +5456,16 @@ function createEndgameSeedTask(taskDb, db, seed, owner) {
 
 function cmdNext(args) {
   const owner = flag(args, '--as') || DEFAULT_OWNER;
+  const scope = taskQueueScopeFromArgs(args);
+  const scoped = !taskQueueScopeIsEmpty(scope);
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  const claimed = taskDb.listTasks(db, {
+  const claimed = filterTasksByScope(taskDb.listTasks(db, {
     workspaceRoot: taskDb.workspaceRoot(),
     status: 'claimed',
     claimedBy: String(owner),
-    limit: 1,
-  });
+    limit: scoped ? null : 1,
+  }), scope);
   if (claimed.length) {
     const { projection, outPath } = writeDefaultProjection(taskDb, db);
     if (wantsJson(args)) {
@@ -5358,6 +5474,7 @@ function cmdNext(args) {
         action: 'current',
         task_id: claimed[0].id,
         owner: String(owner),
+        scope: normalizeTaskQueueScope(scope),
         projection_path: outPath,
         task: compactTaskFromProjection(projection, claimed[0].id),
       });
@@ -5368,14 +5485,14 @@ function cmdNext(args) {
     return;
   }
   const reviewProjection = writeDefaultProjection(taskDb, db);
-  const reviewTasks = (reviewProjection.projection.tasks || [])
+  const reviewTasks = filterTasksByScope(reviewProjection.projection.tasks || [], scope)
     .map(compactTaskForStatus)
     .filter(task => task && task.review && task.review.handoff);
-  const open = taskDb.listTasks(db, {
+  const open = filterTasksByScope(taskDb.listTasks(db, {
     workspaceRoot: taskDb.workspaceRoot(),
     status: 'open',
-    limit: 1,
-  });
+    limit: scoped ? null : 1,
+  }), scope);
   if (!open.length) {
     const { projection, outPath } = reviewProjection;
     const reviewTask = reviewTasks.find(task => task.review.handoff.next_action === 'agent_review_again')
@@ -5405,6 +5522,7 @@ function cmdNext(args) {
             action: 'created_next',
             task_id: created.task_id,
             owner: String(owner),
+            scope: normalizeTaskQueueScope(scope),
             projection_path: createdOutPath,
             handoff,
             next_agent_action: nextAgentAction,
@@ -5427,6 +5545,7 @@ function cmdNext(args) {
           action: handoff.next_action,
           task_id: handoff.next_action === 'continue_work' ? null : reviewTask.id,
           owner: String(owner),
+          scope: normalizeTaskQueueScope(scope),
           projection_path: outPath,
           handoff,
           next_agent_action: nextAgentAction,
@@ -5436,7 +5555,7 @@ function cmdNext(args) {
         });
         return;
       }
-      console.log('No open tasks.');
+      console.log(noOpenTasksMessage(scope));
       console.log(handoff.next_action === 'agent_review_again'
         ? `${taskRef(reviewTask)} needs one more agent check before approval.`
         : `${taskRef(reviewTask)} is ready for approval.`);
@@ -5461,11 +5580,12 @@ function cmdNext(args) {
         action: 'none',
         task_id: null,
         owner: String(owner),
+        scope: normalizeTaskQueueScope(scope),
         projection_path: outPath,
       });
       return;
     }
-    console.log('No open tasks.');
+    console.log(noOpenTasksMessage(scope));
     console.log('Start with: atris task new "..."');
     return;
   }
@@ -5481,6 +5601,7 @@ function cmdNext(args) {
       action: 'next',
       task_id: open[0].id,
       owner: String(owner),
+      scope: normalizeTaskQueueScope(scope),
       projection_path: outPath,
       task: compactTaskFromProjection(projection, open[0].id),
     });
@@ -5837,6 +5958,40 @@ function cmdClearPlan(args) {
   console.log(`clear-plan moved ${result.cleared.length} task${result.cleared.length === 1 ? '' : 's'} to Backlog`);
 }
 
+function cmdInspect(args) {
+  const parsed = readFieldsFlag(args, '--fields');
+  if (!parsed || parsed.error) {
+    failTask('atris task inspect', 'missing_fields', parsed?.error || 'Usage: atris task inspect <id> --fields review,status,title [--json]');
+  }
+  const fieldError = validateFields(parsed.fields, TASK_INSPECT_FIELDS, 'task');
+  if (fieldError) failTask('atris task inspect', 'unknown_fields', fieldError);
+  const ref = stripInspectArgs(args)[0] || '';
+  if (!ref) {
+    failTask('atris task inspect', 'missing_id', 'Usage: atris task inspect <id> --fields review,status,title [--json]');
+  }
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, ref, 'atris task inspect');
+  const projection = enrichTaskProjection(taskDb.taskProjection(db, { taskId }));
+  const task = projection.tasks[0];
+  if (!task) {
+    failTask('atris task inspect', 'not_found', `task not found: ${ref}`, 1);
+  }
+  const values = taskInspectFieldValues(task, parsed.fields);
+  const payload = buildInspectPayload({
+    action: 'task_inspect',
+    idKey: 'task_id',
+    idValue: task.id,
+    fields: parsed.fields,
+    values,
+  });
+  if (wantsJson(args)) {
+    printJson(payload);
+    return;
+  }
+  for (const line of inspectTextLines(parsed.fields, values)) console.log(line);
+}
+
 function cmdShow(args) {
   const pos = positional(args);
   const id = pos[0];
@@ -9912,6 +10067,9 @@ async function run(args) {
       return cmdClearPlan(rest);
     case 'claim':  return cmdClaim(rest);
     case 'start':  return cmdClaim(rest);
+    case 'release':
+    case 'unclaim':
+      return cmdRelease(rest);
     case 'current':
     case 'select':
       return cmdCurrent(rest);
@@ -9957,6 +10115,7 @@ async function run(args) {
     case 'note':   return cmdNote(rest);
     case 'say':    return cmdNote(rest);
     case 'show':   return cmdShow(rest);
+    case 'inspect': return cmdInspect(rest);
     case 'page':   return cmdPage(rest);
     case 'step':   return cmdStep(rest);
     case 'review-chat':

package/commands/truth.js

@@ -1,13 +1,15 @@
 // atris truth — one table of what is actually proven, blocked, or stale.
 // Rolls up sources that already exist; writes nothing. SQL/state is truth, this is the render.
 //   1. .atris/state/missions.jsonl        — mission states (dedupe by id, latest wins)
-//   2. ~/.atris/tasks.db                  — task counts by status
+//   2. ~/.atris/tasks.db                  — task counts by status, scoped to this workspace unless --all is passed
 //   3. atris/features/*/                  — validate.md frontmatter + newest proof/ receipt age
 //   4. ~/.atris/heartbeat/{registry,state}.json — declared loops vs last_run / fails
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execFileSync } = require('child_process');
+const taskDb = require('../lib/task-db');
 
 const STALE_DAYS = 7;
 
@@ -42,16 +44,67 @@ function loadMissions(cwd) {
   return [...seen.values()].filter((m) => m.status && !['complete', 'archived', 'stopped'].includes(m.status));
 }
 
-function loadTaskCounts() {
+function gitCommonWorkspaceRoot(cwd) {
+  try {
+    const common = execFileSync('git', ['rev-parse', '--git-common-dir'], {
+      cwd: cwd || process.cwd(),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    if (!common) return null;
+    const gitDir = path.resolve(cwd || process.cwd(), common);
+    return path.basename(gitDir) === '.git' ? path.dirname(gitDir) : null;
+  } catch {
+    return null;
+  }
+}
+
+function workspaceRootCandidates(cwd) {
+  const primary = taskDb.workspaceRoot(cwd || process.cwd());
+  const candidates = [primary];
+  const commonRoot = gitCommonWorkspaceRoot(primary);
+  if (commonRoot && commonRoot !== primary) candidates.push(commonRoot);
+  return candidates;
+}
+
+function countsFromRows(rows) {
+  const counts = {};
+  for (const r of rows) counts[r.status] = Number(r.n || 0);
+  return counts;
+}
+
+function taskCountRows(db, workspaceRoot) {
+  return workspaceRoot
+    ? db.prepare('SELECT status, COUNT(*) n FROM tasks WHERE workspace_root = ? GROUP BY status').all(workspaceRoot)
+    : db.prepare('SELECT status, COUNT(*) n FROM tasks GROUP BY status').all();
+}
+
+function loadTaskCounts({ cwd, all = false } = {}) {
+  const candidates = all ? [null] : workspaceRootCandidates(cwd || process.cwd());
   try {
     const { DatabaseSync } = require('node:sqlite');
-    const db = new DatabaseSync(path.join(os.homedir(), '.atris', 'tasks.db'), { readOnly: true });
-    const rows = db.prepare('SELECT status, COUNT(*) n FROM tasks GROUP BY status').all();
+    const dbPath = taskDb.getDbPath();
+    if (!fs.existsSync(dbPath)) return { counts: null, workspaceRoot: candidates[0] || null };
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    for (const workspaceRoot of candidates) {
+      const rows = taskCountRows(db, workspaceRoot);
+      if (all || rows.length > 0) {
+        db.close();
+        return { counts: countsFromRows(rows), workspaceRoot };
+      }
+    }
     db.close();
-    const counts = {};
-    for (const r of rows) counts[r.status] = r.n;
-    return counts;
-  } catch { return null; }
+    return { counts: {}, workspaceRoot: candidates[0] || null };
+  } catch { return { counts: null, workspaceRoot: candidates[0] || null }; }
+}
+
+function taskScopeLabel(scope) {
+  return scope.kind === 'global' ? 'global' : 'workspace';
+}
+
+function taskScopeLine(scope) {
+  if (scope.kind === 'global') return 'global';
+  return `${taskScopeLabel(scope)} (${scope.workspace_root})`;
 }
 
 function loadFeatures(cwd) {
@@ -111,9 +164,14 @@ function truthCommand(args = []) {
   const cwd = process.cwd();
   const json = args.includes('--json');
   const summary = args.includes('--summary');
+  const all = args.includes('--all');
 
   const missions = loadMissions(cwd);
-  const tasks = loadTaskCounts();
+  const taskCounts = loadTaskCounts({ cwd, all });
+  const scope = all
+    ? { kind: 'global' }
+    : { kind: 'workspace', workspace_root: taskCounts.workspaceRoot };
+  const tasks = taskCounts.counts;
   const features = loadFeatures(cwd);
   const heartbeats = loadHeartbeats();
 
@@ -125,6 +183,7 @@ function truthCommand(args = []) {
   const result = {
     ok: true,
     generated_at: new Date().toISOString(),
+    scope,
     missions_active: missions.map((m) => ({ id: m.id || m.mission_id, status: m.status, owner: m.owner })),
     tasks,
     features: featureTally,
@@ -140,11 +199,12 @@ function truthCommand(args = []) {
 
   const line = (s) => console.log(s);
   if (summary) {
-    line(`truth: features ${featureTally.proven || 0} proven / ${featureTally.stale || 0} stale / ${featureTally.blocked || 0} blocked / ${featureTally.unproven || 0} unproven · loops ${loopTally.proven || 0} live / ${(loopTally.stale || 0) + (loopTally['never-ran'] || 0)} stale / ${loopTally.blocked || 0} failing · missions ${missions.length} active`);
+    line(`truth [${taskScopeLabel(scope)}]: features ${featureTally.proven || 0} proven / ${featureTally.stale || 0} stale / ${featureTally.blocked || 0} blocked / ${featureTally.unproven || 0} unproven · loops ${loopTally.proven || 0} live / ${(loopTally.stale || 0) + (loopTally['never-ran'] || 0)} stale / ${loopTally.blocked || 0} failing · missions ${missions.length} active`);
     return 0;
   }
 
   line('ATRIS TRUTH — live state, not belief\n');
+  line(`Scope: ${taskScopeLine(scope)}`);
 
   line(`Missions active: ${missions.length}`);
   for (const m of missions) line(`  ${m.status.padEnd(8)} ${m.owner || '?'}  ${m.id || m.mission_id}`);