atris 3.15.52 → 3.15.54

package/atris/features/README.md

@@ -79,17 +79,20 @@ cp atris/features/_templates/validate.md.template atris/features/your-feature-na
 
 ### Active Features
 
-#### audit-gaps
-Close remaining audit gaps from self-audit
-- **Files:** atris/team/*.md, atris/features/README.md
-- **Status:** complete
-- **Keywords:** audit, persona, cleanup
-- **What:** Add PERSONA.md reference to all 5 agent specs, clean up stale feature statuses
+None.
 
 ---
 
 ### Completed Features
 
+#### audit-gaps
+Close remaining audit gaps from self-audit
+- **Files:** atris/team/*/MEMBER.md, atris/features/README.md, atris/features/audit-gaps/*
+- **Status:** complete
+- **Keywords:** audit, persona, cleanup
+- **What:** Agent member specs reference PERSONA.md for communication style, and stale feature statuses are cleaned up
+- **Completed:** 2026-05-19
+
 #### endstate
 Public benchmark for proving a coordinated stack beats a pinned single-model baseline
 - **Files:** atris/features/endstate/*, commands/autopilot.js, commands/experiments.js, commands/loop.js, lib/wiki.js
@@ -116,7 +119,7 @@ Local-first project wiki with cloud opt-in
 
 #### self-improving-loop
 Make Atris recursive — validate.md lessons feed back into the next idea.md
-- **Files:** atris/lessons.md (new), atris.md, atris/team/navigator.md, atris/team/validator.md, atris/MAP.md
+- **Files:** atris/lessons.md (new), atris.md, atris/team/navigator/MEMBER.md, atris/team/validator/MEMBER.md, atris/MAP.md
 - **Status:** complete
 - **Keywords:** recursion, lessons, feedback-loop, self-improving, lessons.md
 - **What:** lessons.md accumulates validated learnings; navigator reads them before planning; validator harvests them after validating

package/commands/computer.js

@@ -1126,15 +1126,35 @@ async function resolveComputerCommandContext(token, options = {}) {
       ? await resolveBusinessContextBySlug(token, options.businessSlug, { preferCache: true })
       : await resolveBusinessContext(token);
     if (!ctx?.businessId) return null;
+    const workspaceId = options.workspaceId
+      ? await resolveWorkspaceSelector(token, ctx, options.workspaceId)
+      : ctx.workspaceId;
     return {
       ...ctx,
-      workspaceId: options.workspaceId || ctx.workspaceId,
+      workspaceId,
     };
   }
 
   return resolveBusinessContext(token);
 }
 
+function looksLikeWorkspaceId(input) {
+  const value = String(input || '').trim();
+  if (!value) return false;
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)
+    || /^ws-[a-z0-9_-]+$/i.test(value);
+}
+
+async function resolveWorkspaceSelector(token, ctx, input) {
+  const selector = String(input || '').trim();
+  if (!selector) return ctx.workspaceId;
+  if (selector === ctx.workspaceId || looksLikeWorkspaceId(selector)) return selector;
+
+  const workspaces = await listBusinessWorkspaces(token, ctx);
+  const workspace = resolveWorkspaceFromList(workspaces, selector);
+  return workspace?.id || selector;
+}
+
 async function resolveBusinessOwnerForCreate(token, businessSlug = null) {
   const wantedSlug = businessSlug ? String(businessSlug).trim() : null;
   if (wantedSlug) {
@@ -1260,6 +1280,18 @@ function formatWorkspaceRef(workspace) {
   return workspace.name ? `${workspace.name} (${workspace.id})` : workspace.id;
 }
 
+function workspaceMatchesInput(workspace, input) {
+  if (!workspace || !input) return false;
+  const wanted = String(input).trim().toLowerCase();
+  if (!wanted) return false;
+  return String(workspace.id || '').toLowerCase() === wanted
+    || String(workspace.name || '').toLowerCase() === wanted;
+}
+
+function resolveWorkspaceFromList(workspaces, input) {
+  return (workspaces || []).find((workspace) => workspaceMatchesInput(workspace, input)) || null;
+}
+
 function formatLeaseAge(seconds) {
   const value = Number(seconds);
   if (!Number.isFinite(value) || value < 0) return '-';
@@ -1519,7 +1551,11 @@ async function computerStatus(token, ctx = null) {
     if (d.endpoint) console.log(`    Endpoint: ${d.endpoint}`);
     const workspaces = await listBusinessWorkspaces(token, ctx);
     const defaultWorkspace = workspaces.find((workspace) => workspace.is_default);
-    const targetWorkspace = workspaces.find((workspace) => workspace.id === ctx.workspaceId) || (ctx.workspaceId ? { id: ctx.workspaceId } : null);
+    const resolvedTargetWorkspace = resolveWorkspaceFromList(workspaces, ctx.workspaceId);
+    const targetWorkspace = resolvedTargetWorkspace || (ctx.workspaceId ? { id: ctx.workspaceId } : null);
+    const probeCtx = resolvedTargetWorkspace?.id
+      ? { ...ctx, workspaceId: resolvedTargetWorkspace.id }
+      : ctx;
     console.log(`    Default workspace:  ${formatWorkspaceRef(defaultWorkspace)}`);
     console.log(`    Target workspace:   ${formatWorkspaceRef(targetWorkspace)}`);
     const attachedFromStatus = d.attached_workspace_id
@@ -1534,8 +1570,8 @@ async function computerStatus(token, ctx = null) {
       console.log(`    Lease age:          ${formatLeaseAge(d.lease_age_seconds)}`);
       if (d.takeover_hint) console.log(`    Takeover hint:      ${d.takeover_hint}`);
     }
-    if (status === 'running' && d.endpoint && ctx.workspaceId) {
-      const attached = await probeAttachedWorkspace(token, ctx);
+    if (status === 'running' && d.endpoint && probeCtx.workspaceId) {
+      const attached = await probeAttachedWorkspace(token, probeCtx);
       if (!attachedFromStatus) {
         const attachedWorkspace = workspaces.find((workspace) => workspace.id === attached.workspaceId) || (attached.workspaceId ? { id: attached.workspaceId } : null);
         console.log(`    Attached workspace: ${formatWorkspaceRef(attachedWorkspace)}`);

package/commands/mission.js

@@ -748,12 +748,18 @@ function missionVerifierPassed(mission) {
 
 function missionDueAt(mission, now = new Date()) {
   const cadenceSeconds = parseCadenceSeconds(mission.cadence);
-  if (!mission.last_tick_at || cadenceSeconds === 0) return true;
+  if (!mission.last_tick_at) return true;
+  if (cadenceSeconds === 0) return !(mission.always_on && missionVerifierPassed(mission));
   const lastTickAt = Date.parse(mission.last_tick_at);
   if (!Number.isFinite(lastTickAt)) return true;
   return now.getTime() - lastTickAt >= cadenceSeconds * 1000;
 }
 
+function missionSelectableForLoop(mission, now = new Date()) {
+  return missionIsRunnable(mission)
+    && !(mission.always_on && missionVerifierPassed(mission) && !missionDueAt(mission, now));
+}
+
 function secondsUntilMissionDue(mission, now = new Date()) {
   const cadenceSeconds = parseCadenceSeconds(mission?.cadence);
   if (!mission || !mission.last_tick_at || cadenceSeconds === 0) return 0;
@@ -780,7 +786,7 @@ function missionSortTime(mission) {
 
 function selectDueMission(root = process.cwd(), now = new Date()) {
   const candidates = listMissions(root)
-    .filter(missionIsRunnable)
+    .filter((mission) => missionSelectableForLoop(mission, now))
     .filter((mission) => mission.verifier)
     .filter((mission) => mission.always_on || !missionVerifierPassed(mission))
     .filter((mission) => missionDueAt(mission, now));
@@ -799,7 +805,7 @@ function selectDueMission(root = process.cwd(), now = new Date()) {
 
 function selectCodexGoalMission(root = process.cwd(), now = new Date()) {
   const candidates = listMissions(root)
-    .filter(missionIsRunnable);
+    .filter((mission) => missionSelectableForLoop(mission, now));
 
   candidates.sort((a, b) => {
     const aCaller = runnerUsesCallerSession(a.runner) ? 1 : 0;

package/commands/radar.js

@@ -432,6 +432,31 @@ function ownerForTask(task) {
   return task.assigned_to || task.claimed_by || task.metadata?.assigned_to || '-';
 }
 
+function taskSessionReason(task) {
+  if (!task) return null;
+  if (task.status === 'review') return task.metadata?.agent_certified ? 'certified review' : 'review task';
+  if (ownerActionRequired(task)) return 'owner action required';
+  return null;
+}
+
+function taskSessionAction(agent, task, taskWorkspaceRoot) {
+  if (!task) return null;
+  const ref = taskRef(task);
+  const pid = agent?.pid || '?';
+  const actor = agent?.agent || 'agent';
+  const reviewCommand = taskWorkspaceRoot
+    ? `cd ${shellQuote(taskWorkspaceRoot)} && atris task reviews --limit 5`
+    : 'atris task reviews --limit 5';
+  if (task.status === 'review') {
+    if (task.metadata?.agent_certified) {
+      return `handoff complete for ${ref}; close pid ${pid} or claim fresh work as ${actor}`;
+    }
+    return `review or hand off ${ref}: ${reviewCommand}`;
+  }
+  if (ownerActionRequired(task)) return `owner-gated ${ref}; close pid ${pid} or wait for owner action`;
+  return null;
+}
+
 function summarize(tasks, missions, worktrees, agents) {
   const count = (rows, pred) => rows.filter(pred).length;
   return {
@@ -505,7 +530,7 @@ function collectRadar(options = {}) {
     const taskWorkspaceRoot = findTaskWorkspaceRoot(agent.cwd, deps);
     const agentTasks = taskWorkspaceRoot ? loadTasksCached(taskWorkspaceRoot, deps, taskCache) : [];
     const task = taskForCwd(agentTasks, agent.cwd, taskWorkspaceRoot);
-    const taskReason = task ? null : untaskedReason(agent, taskWorkspaceRoot, agentTasks);
+    const taskReason = task ? taskSessionReason(task) : untaskedReason(agent, taskWorkspaceRoot, agentTasks);
     return {
       ...agent,
       task: taskRef(task),
@@ -513,7 +538,7 @@ function collectRadar(options = {}) {
       owner: ownerForTask(task),
       task_workspace: taskWorkspaceRoot ? repoLabel(taskWorkspaceRoot) : null,
       task_reason: taskReason,
-      task_action: task ? null : untaskedAction(agent, taskWorkspaceRoot, agentTasks),
+      task_action: task ? taskSessionAction(agent, task, taskWorkspaceRoot) : untaskedAction(agent, taskWorkspaceRoot, agentTasks),
     };
   });
   const osState = {
@@ -624,6 +649,11 @@ function sortedAgents(agents = []) {
 function agentProcessNextAction(agents = [], fallback = 'no obvious process action') {
   const stopped = agents.filter(agent => agent.status !== 'active').length;
   if (stopped > 0) return `inspect ${stopped} stopped agent session${stopped === 1 ? '' : 's'}`;
+  const ownerGated = agents.filter(agent => agent.task_reason === 'owner action required');
+  if (ownerGated.length > 0) {
+    const tasks = [...new Set(ownerGated.map(agent => agent.task).filter(Boolean))].slice(0, 3).join(', ');
+    return `owner gate blocks ${ownerGated.length} session${ownerGated.length === 1 ? '' : 's'}${tasks ? ` on ${tasks}` : ''}; wait for owner action or close idle sessions`;
+  }
   const taskLoad = summarizeTaskLoad(agents);
   const reviewBound = taskLoad.find(row => row.status.split(/,\s*/).includes('review'));
   if (reviewBound) return `close or hand off ${reviewBound.sessions} session${reviewBound.sessions === 1 ? '' : 's'} still bound to review task ${reviewBound.task}`;
@@ -744,6 +774,22 @@ function renderAgentTop(data) {
       lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'}: ${agent.task_reason || 'unmapped'} -> ${agent.task_action || 'inspect session'}`);
     }
   }
+  const ownerGatedAgents = payload.agents.filter(row => row.task_reason === 'owner action required').slice(0, 8);
+  if (ownerGatedAgents.length) {
+    lines.push('');
+    lines.push(`Owner-gated: ${ownerGatedAgents.length} session${ownerGatedAgents.length === 1 ? '' : 's'} waiting on owner-only tasks.`);
+    for (const agent of ownerGatedAgents) {
+      lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'} ${agent.task}: ${agent.task_action || 'wait for owner action'}`);
+    }
+  }
+  const reviewBoundAgents = payload.agents.filter(row => row.task_status === 'review').slice(0, 8);
+  if (reviewBoundAgents.length) {
+    lines.push('');
+    lines.push(`Review-bound: ${reviewBoundAgents.length} session${reviewBoundAgents.length === 1 ? '' : 's'} still tied to Review tasks.`);
+    for (const agent of reviewBoundAgents) {
+      lines.push(`- ${agent.pid} ${agent.repo || agent.cwd || '-'} ${agent.task}: ${agent.task_reason || 'review'} -> ${agent.task_action || 'close or hand off session'}`);
+    }
+  }
   const taskLoadRows = payload.task_load.filter(row => row.attention).slice(0, 8);
   if (taskLoadRows.length) {
     lines.push('');

package/commands/worktree.js

@@ -285,6 +285,12 @@ function createOrFindPr(root, branch, targetRef, title, dryRun) {
   return created.stdout.trim();
 }
 
+function prMergeRef(prOutput) {
+  const text = String(prOutput || '').trim();
+  if (!text || text.startsWith('dry-run:')) return '';
+  return text.split(/\s+/)[0];
+}
+
 function shipWorktree(args) {
   const root = repoRoot();
   const dryRun = hasFlag(args, '--dry-run');
@@ -359,8 +365,20 @@ function shipWorktree(args) {
     if (merge) {
       console.log('merge: requested');
       if (!dryRun) {
-        const merged = spawnSync('gh', ['pr', 'merge', '--merge', '--delete-branch'], { cwd: root, encoding: 'utf8' });
+        const mergeRef = prMergeRef(pr);
+        const mergeArgs = ['pr', 'merge'];
+        if (mergeRef) mergeArgs.push(mergeRef);
+        mergeArgs.push('--merge');
+        const merged = spawnSync('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
         if (merged.status !== 0) throw new Error((merged.stderr || merged.stdout || 'gh pr merge failed').trim());
+        console.log('merge: merged');
+        const deleted = runGit(['push', 'origin', '--delete', branch], { cwd: root, check: false });
+        if (deleted.status === 0) {
+          console.log(`merge: remote branch deleted ${branch}`);
+        } else {
+          const deleteOutput = (deleted.stderr || deleted.stdout || 'remote branch delete failed').trim();
+          console.log(`merge: remote branch delete skipped: ${deleteOutput}`);
+        }
       }
     }
   } else {
@@ -461,6 +479,7 @@ module.exports = {
   defaultWorktreePath,
   parseWorktrees,
   normalizeTargetRef,
+  prMergeRef,
   slugify,
   statusCounts,
   swarloClaim,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.15.52",
+  "version": "3.15.54",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",