atris 3.30.1 → 3.30.3

package/commands/task.js

@@ -11,6 +11,10 @@ const { taskProofState, buildVerifiedProof } = require('../lib/task-proof');
 const { evaluateAutoAccept, parseVerifyCommand } = require('../lib/auto-accept-certified');
 const { extractReceiptEvidence } = require('../lib/receipt-evidence');
 const escapeRegExp = require('../lib/escape-regexp');
+const {
+  normalizeOwnerSlug,
+  resolveFunctionalOwner: resolveFunctionalTaskOwner,
+} = require('../lib/functional-owner');
 
 const DEFAULT_OWNER = process.env.ATRIS_AGENT_ID
   || process.env.USER
@@ -102,6 +106,8 @@ atris task - durable local task state (SQLite, gitignored)
                                            Show the plain Plan before work starts
   atris task ready <id> --proof "..." [--changed "..." --checked "..." --saved "..." --try "..."]
                                            Agent proof ready; records Result if needed
+  atris task ready <id> --proof "..." [--happened "..." --checked "..." --tested "..." --decision "..."]
+                                           Agent proof ready; writes the human result receipt
   atris task result <id> --changed "..." --checked "..." [--saved "..."] [--try "..."]
                                            Show the plain Result and store trace on the task
   atris task review-chat <id> [--as <owner>]  Start a task-owned /codex verification chat
@@ -112,7 +118,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task revise <id> --note "..."      Send reviewed work back to Do
 
   atris task add "<title>" [--tag <tag>] [--goal-id <id>]  Create a task
-  atris task delegate "<title>" --to <id> [--goal-id <id>]  Create an assigned task
+  atris task delegate "<title>" [--to <member>] [--executed-by <engine>] [--goal-id <id>]  Create assigned work
   atris task plan <id> --goal "..." --exit "..." --proof-needed "..."
                                            Record a task-owned Plan stage
   atris task do <id> --as <owner> --first-move "..."
@@ -145,7 +151,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task review <id> --reward <n> [--verify "<cmd>"]
                                            Write review event + RSI episode
   atris task reviews [--limit <n>]         Show certified Review items for human accept/revise
-  atris task reviews --group-by <tag|owner|source>   Cluster the certified wall for fast triage
+  atris task reviews --group-by <tag|owner|source>   Cluster ready-to-land work for fast triage
   atris task accept-group <key>=<value> --spot-check K --confirm-human-accept --as <you> --verified <ids>
                                            Accept a whole cluster; career XP only on the K you verified
   atris task status [--json] [--history]   Compact live status for web/Swarlo
@@ -309,6 +315,15 @@ function textFlag(args, names) {
   return '';
 }
 
+function landingFlags(args) {
+  return {
+    happened: textFlag(args, ['--happened', '--what-happened']),
+    checked: textFlag(args, ['--checked', '--how-checked']),
+    tested: textFlag(args, ['--tested', '--what-tested']),
+    decision: textFlag(args, ['--decision', '--acceptance']),
+  };
+}
+
 function numericFlag(args, name) {
   const value = flag(args, name);
   if (value === null || value === true || value === undefined) return null;
@@ -645,6 +660,10 @@ function reviewSummary(task, payload = {}) {
 
   const title = String(task.title || 'this task').replace(/\s+/g, ' ').trim();
   const plainTitle = title ? title.charAt(0).toLowerCase() + title.slice(1) : 'this task';
+  const approvalStatus = payload.approval_status || metadata.approval_status || null;
+  if (approvalStatus === 'revise') {
+    return `Rework requested for ${plainTitle}.`;
+  }
   const careerText = [
     task.tag,
     metadata.goal_id,
@@ -659,20 +678,148 @@ function reviewSummary(task, payload = {}) {
     || careerText.includes('agent xp')
   ) {
     if (task.status === 'done') {
-      return `This is accepted AgentXP work: ${plainTitle} is done and has a proof receipt.`;
+      return `Landed AgentXP result for ${plainTitle}.`;
     }
     if (task.status === 'review') {
-      return `This is AgentXP review: ${plainTitle} is agent-complete; accept only if the proof is real.`;
+      return `${plainTitle} is ready to land; land only if the proof is real.`;
     }
-    return `This explains what accepting ${plainTitle} would make real for AgentXP.`;
+    return `This explains what landing ${plainTitle} would make real for AgentXP.`;
   }
   if (task.status === 'done') {
-    return `This is the accepted outcome: ${plainTitle} is done and counted as real work.`;
+    return `Landed result for ${plainTitle}.`;
   }
   if (task.status === 'review') {
-    return `This is the human checkpoint: ${plainTitle} is agent-complete and needs acceptance before it counts as done.`;
-  }
-  return `This explains what accepting ${plainTitle} would make real.`;
+    return `${plainTitle} is ready to land; land it or send it back.`;
+  }
+  return `This explains what landing ${plainTitle} would make real.`;
+}
+
+function titleToResultText(title) {
+  const text = String(title || 'this task').replace(/\s+/g, ' ').trim();
+  if (!text) return 'This task is ready to review.';
+  const [first, ...restParts] = text.split(' ');
+  const rest = restParts.join(' ');
+  const past = {
+    add: 'Added',
+    approve: 'Prepared approval for',
+    build: 'Built',
+    clean: 'Cleaned',
+    create: 'Created',
+    design: 'Designed',
+    document: 'Documented',
+    fix: 'Fixed',
+    make: 'Made',
+    replace: 'Replaced',
+    route: 'Routed',
+    run: 'Ran',
+    ship: 'Shipped',
+    update: 'Updated',
+    validate: 'Validated',
+    wire: 'Wired',
+  }[String(first || '').toLowerCase()];
+  if (past && rest) return `${past} ${rest}.`;
+  return `${text} is ready to review.`;
+}
+
+function titleToReasonText(task, proof = '') {
+  const title = String(task?.title || '').replace(/\s+/g, ' ').trim();
+  const text = `${title} ${proof || ''}`.toLowerCase();
+  if (/\b(priv(?:ate|acy)|secret|payload|leak|redact)\b/.test(text)) {
+    return 'It keeps private data out of the fast human decision screen.';
+  }
+  if (/\bapprove\b/.test(text) && /\b(command|exact|preview|ux)\b/.test(text)) {
+    return 'It lets the operator see the next command without hunting.';
+  }
+  if (/\b(stale|expire|expired)\b/.test(text) && /\bapproval/.test(text)) {
+    return 'It stops old approvals from running after their context has gone stale.';
+  }
+  if (/\bapproval|approve|permission\b/.test(text)) {
+    return 'It keeps real-world side effects behind a clear human decision.';
+  }
+  if (/\btest|self-test|harness|verifier|proof\b/.test(text)) {
+    return 'It makes the check repeatable before the work lands.';
+  }
+  return 'It closes the user-visible gap named by the task.';
+}
+
+function proofToHumanCheck(proof) {
+  const text = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!text) return 'Proof is attached below.';
+  const lower = text.toLowerCase();
+  if (/\b(?:atris\s+)?task\s+(?:show|page)\b/.test(lower) && /\b(?:print|prints|printed|render|renders|rendered|show|shows|showed)\b/.test(lower)) {
+    return 'I opened the real task screen and checked the receipt renders before raw proof.';
+  }
+  if (/git\s+diff\s+--check/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) {
+    if (/node\s+--test/.test(lower)) return 'I ran the behavior check and the diff cleanliness check.';
+    return 'I ran the diff cleanliness check.';
+  }
+  if (/\btypecheck\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the typecheck.';
+  if (/\bbuild\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the build check.';
+  if (/\btest\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the verifier named in the proof.';
+  if (/\bvalidat(?:e|ion|ed)\b/.test(lower) && /\bpass(?:ed)?\b/.test(lower)) return 'I ran the validation check.';
+  if (/\breview(?:ed)?\b/.test(lower)) return 'Review proof is attached below.';
+  return 'Proof is attached below.';
+}
+
+function taskReviewLandingTested(proof) {
+  const commands = taskReviewEvidenceCommands(proof, 3);
+  if (commands.length) return `I ran: ${commands.join(' | ')}.`;
+  const paths = taskReviewEvidencePaths(proof, 3);
+  if (paths.length) return `I inspected: ${paths.join(', ')}.`;
+  return String(proof || '').trim() ? 'I attached the proof below.' : 'No verifier command recorded yet.';
+}
+
+function landingPayloadValue(payload, metadata, key) {
+  const landing = payload && payload.landing && typeof payload.landing === 'object' ? payload.landing : {};
+  return landing[key]
+    || payload && payload[`landing_${key}`]
+    || metadata[`landing_${key}`]
+    || null;
+}
+
+function taskReviewLanding(task, review = {}, payload = {}) {
+  const metadata = task.metadata || {};
+  const proof = review.proof || payload.proof || metadata.latest_agent_proof || '';
+  const agentCertified = review.agent_certified === true || metadata.agent_certified === true;
+  const approvalStatus = review.approval_status || metadata.approval_status || null;
+  const explicitHappened = landingPayloadValue(payload, metadata, 'happened')
+    || payload.changed || metadata.result_changed || metadata.human_changed || metadata.changed;
+  const explicitChecked = landingPayloadValue(payload, metadata, 'checked')
+    || payload.checked || metadata.result_checked || metadata.human_checked || metadata.checked;
+  const explicitTested = landingPayloadValue(payload, metadata, 'tested');
+  const explicitDecision = landingPayloadValue(payload, metadata, 'decision');
+  const explicitReason = landingPayloadValue(payload, metadata, 'reason')
+    || landingPayloadValue(payload, metadata, 'why')
+    || payload.reason || payload.why || metadata.result_reason || metadata.review_reason || metadata.why_it_matters;
+  return {
+    happened: clipStatusText(explicitHappened || titleToResultText(task.title), 220),
+    reason: clipStatusText(explicitReason || titleToReasonText(task, proof), 220),
+    checked: clipStatusText(explicitChecked || proofToHumanCheck(proof), 220),
+    tested: clipStatusText(explicitTested || taskReviewLandingTested(proof), 260),
+    decision: clipStatusText(explicitDecision || (task.status === 'done'
+      ? 'Landed. No action needed unless this regresses.'
+      : approvalStatus === 'revise'
+        ? 'Rework requested. Fix the note, then send a new receipt.'
+        : approvalStatus === 'pending' && !agentCertified
+          ? 'Needs one more check before landing; send it back if the receipt misses the point.'
+          : 'Land it if this matches the request; send it back if not.'), 220),
+  };
+}
+
+function taskReviewResult(task, review = {}, payload = {}) {
+  const metadata = task.metadata || {};
+  const ref = taskRef(task);
+  const landing = taskReviewLanding(task, review, payload);
+  const explicitSaved = payload.saved || metadata.result_saved || metadata.human_saved || metadata.saved;
+  return {
+    changed: landing.happened,
+    reason: landing.reason,
+    checked: landing.checked,
+    saved: clipStatusText(explicitSaved || (task.status === 'done'
+      ? `Landed as ${ref}.`
+      : `Ready to land as ${ref}.`), 180),
+    accept: landing.decision,
+  };
 }
 
 function taskReviewSummary(task) {
@@ -681,7 +828,7 @@ function taskReviewSummary(task) {
   const metadata = task.metadata || {};
   if (!reviewed && !metadata.approval_status && !metadata.agent_review_pass_count && !metadata.human_revision_count && !metadata.agent_certified) return null;
   if (reviewed && reviewed.event_type === 'revision_requested') {
-    return reviewSummaryWithVerificationChat(task, {
+    const review = {
       summary: reviewSummary(task, payload),
       reward: null,
       proof: null,
@@ -693,7 +840,10 @@ function taskReviewSummary(task) {
       agent_certification_policy: null,
       human_revision_count: metadata.human_revision_count || payload.revision_count || null,
       human_revision_note: metadata.human_revision_note || payload.note || null,
-    });
+    };
+    review.landing = taskReviewLanding(task, review, payload);
+    review.result = taskReviewResult(task, review, payload);
+    return reviewSummaryWithVerificationChat(task, review);
   }
   const reviewPassCount = Number(metadata.agent_review_pass_count || payload.review_pass_count || 0);
   const agentCertified = metadata.agent_certified === true
@@ -713,7 +863,7 @@ function taskReviewSummary(task) {
     }
     return payload[key] || metadata[metadataKey] || null;
   };
-  return reviewSummaryWithVerificationChat(task, {
+  const review = {
     summary: reviewSummary(task, payload),
     reward: reviewed && reviewed.event_type === 'reviewed' && payload.reward !== undefined ? payload.reward : null,
     proof: readyField('proof', 'latest_agent_proof'),
@@ -726,7 +876,10 @@ function taskReviewSummary(task) {
       || payload.agent_certification_policy
       || (agentCertified ? `${AGENT_CERTIFICATION_REVIEW_PASSES}_agent_review_passes` : null),
     human_revision_count: metadata.human_revision_count || null,
-  });
+  };
+  review.landing = taskReviewLanding(task, review, payload);
+  review.result = taskReviewResult(task, review, payload);
+  return reviewSummaryWithVerificationChat(task, review);
 }
 
 function reviewSummaryWithVerificationChat(task, review) {
@@ -951,6 +1104,15 @@ function taskDescriptionForCloud(task) {
       lines.push(`- ${message.actor || 'unknown'}: ${message.content}`);
     }
   }
+  const landing = reviewLandingForDisplay(task.review);
+  if (landing) {
+    lines.push('', 'Result:');
+    if (landing.happened) lines.push(`What happened: ${landing.happened}`);
+    if (landing.reason) lines.push(`Why it matters: ${landing.reason}`);
+    if (landing.checked) lines.push(`How checked: ${landing.checked}`);
+    if (landing.tested) lines.push(`Tested: ${landing.tested}`);
+    if (landing.decision) lines.push(`Decision: ${landing.decision}`);
+  }
   const reviewed = (task.events || []).slice().reverse().find(e => e.event_type === 'reviewed');
   if (reviewed && reviewed.payload) {
     if (reviewed.payload.proof) lines.push('', `Proof: ${reviewed.payload.proof}`);
@@ -964,6 +1126,32 @@ function taskDescriptionForCloud(task) {
   return lines.join('\n').slice(0, 5000);
 }
 
+function reviewLandingForDisplay(review) {
+  if (!review) return null;
+  if (review.landing) return review.landing;
+  if (!review.result) return null;
+  return {
+    happened: review.result.changed || null,
+    reason: review.result.reason || null,
+    checked: review.result.checked || null,
+    tested: review.proof ? taskReviewLandingTested(review.proof) : null,
+    decision: review.result.accept || null,
+  };
+}
+
+function printReviewLanding(review) {
+  const landing = reviewLandingForDisplay(review);
+  if (!landing) return false;
+  console.log('Result:');
+  if (landing.happened) console.log(`  What happened: ${landing.happened}`);
+  if (landing.reason) console.log(`  Why it matters: ${landing.reason}`);
+  if (landing.checked) console.log(`  How I checked: ${landing.checked}`);
+  if (landing.tested) console.log(`  What I tested: ${landing.tested}`);
+  if (review.result && review.result.saved) console.log(`  Saved: ${review.result.saved}`);
+  if (landing.decision) console.log(`  Decision: ${landing.decision}`);
+  return true;
+}
+
 function cloudPayloadForTask(task, businessId) {
   const metadata = task.metadata || {};
   const claimedAtEvent = (task.events || []).find(e => e.event_type === 'claimed');
@@ -1381,6 +1569,8 @@ function compactTaskForStatus(task) {
     const review = {};
     if (typeof task.review.reward === 'number') review.reward = task.review.reward;
     else if (task.review.reward === null) review.reward = null;
+    if (task.review.landing) review.landing = task.review.landing;
+    if (task.review.result) review.result = task.review.result;
     if (task.review.summary) review.summary = clipStatusText(task.review.summary, 240);
     if (task.review.proof) review.proof = clipStatusText(task.review.proof, 180);
     if (task.review.lesson) review.lesson = clipStatusText(task.review.lesson, 180);
@@ -1404,7 +1594,7 @@ function compactTaskForStatus(task) {
     if (Object.keys(lineage).length) out.lineage = lineage;
   }
   const compactMetadata = {};
-  for (const key of ['todo_id', 'stage', 'verify', 'delegate_via', 'goal_id', 'task_goal', 'goal_objective', 'approval_status', 'agent_review_pass_count', 'agent_certified', 'agent_certification_policy', 'human_revision_count', 'human_revision_note']) {
+  for (const key of ['todo_id', 'stage', 'verify', 'delegate_via', 'owner_resolution', 'requested_owner', 'executed_by', 'proposed_member', 'proposed_member_command', 'goal_id', 'task_goal', 'goal_objective', 'approval_status', 'agent_review_pass_count', 'agent_certified', 'agent_certification_policy', 'human_revision_count', 'human_revision_note']) {
     if (metadata[key]) compactMetadata[key] = key === 'verify' ? clipStatusText(metadata[key], 180) : metadata[key];
   }
   if (Object.keys(compactMetadata).length) out.metadata = compactMetadata;
@@ -1598,9 +1788,20 @@ function sortTasksNewestFirst(tasks) {
   });
 }
 
+function sortTasksOldestFirst(tasks) {
+  return [...tasks].sort((a, b) => {
+    const byUpdated = Number(a.updated_at || 0) - Number(b.updated_at || 0);
+    if (byUpdated) return byUpdated;
+    return String(a.title || '').localeCompare(String(b.title || ''));
+  });
+}
+
 function taskQueueItem(task, { reviewer = 'codex-review', hasExistingReviewFollowUp = null } = {}) {
   const page = taskPageContract(task, { reviewer, hasExistingReviewFollowUp });
   const item = compactTaskForStatus(task) || {};
+  item.ref = taskRef(task);
+  item.display_id = item.display_id || task.display_id || null;
+  item.legacy_ref = item.legacy_ref || task.legacy_ref || taskRef(task.id);
   if (item.review && item.review.verification_chat) {
     item.review = { ...item.review };
     delete item.review.verification_chat;
@@ -2682,7 +2883,8 @@ function taskQueueContract(projection, { reviewer = 'codex-review', limit = 8, s
 }
 
 function selectTaskForCurrent(projection, { owner = DEFAULT_OWNER, scope = {}, hasExistingReviewFollowUp = null } = {}) {
-  const tasks = filterTasksByScope(sortTasksNewestFirst(projection.tasks || []), scope, { hasExistingReviewFollowUp });
+  const normalizedScope = normalizeTaskQueueScope(scope);
+  const tasks = filterTasksByScope(sortTasksNewestFirst(projection.tasks || []), normalizedScope, { hasExistingReviewFollowUp });
   const columns = {
     backlog: [],
     plan: [],
@@ -2703,7 +2905,8 @@ function selectTaskForCurrent(projection, { owner = DEFAULT_OWNER, scope = {}, h
   if (reviewNeedsAgent) return { task: reviewNeedsAgent, reason: 'review_needs_agent_verification' };
   const reviewProofBoundaryBlocked = columns.review.find(task => reviewHandoffForTask(task, { suppressExistingFollowUp: true, hasExistingReviewFollowUp })?.next_action === PROOF_BOUNDARY_BLOCKED_ACTION);
   if (reviewProofBoundaryBlocked) return { task: reviewProofBoundaryBlocked, reason: 'review_proof_boundary_blocked' };
-  const planReady = columns.plan[0];
+  const planQueue = normalizedScope.goal_id ? sortTasksOldestFirst(columns.plan) : columns.plan;
+  const planReady = planQueue[0];
   if (planReady) return { task: planReady, reason: 'plan_ready' };
   const backlogIdea = columns.backlog[0];
   if (backlogIdea) return { task: backlogIdea, reason: 'backlog_idea' };
@@ -3821,10 +4024,14 @@ function reviewQueueItem(task, root = process.cwd(), evidence = undefined) {
     tag: task.tag || null,
     updated_at: task.updated_at || null,
     review_pass_count: task.review?.agent_review_pass_count || null,
+    landing: reviewLandingForDisplay(task.review),
+    result: task.review?.result || null,
     proof: taskReviewClip(task.review?.proof, 500) || null,
     next_action: handoff?.next_action || null,
     accept_command: acceptCommand,
+    land_command: acceptCommand,
     revise_command: `atris task revise ${ref} --note "<what must change>"`,
+    send_back_command: `atris task revise ${ref} --note "<what must change>"`,
   };
   const resolvedEvidence = evidence === undefined ? extractReceiptEvidence(task.review?.proof, root) : evidence;
   if (resolvedEvidence) item.evidence = resolvedEvidence;
@@ -3968,13 +4175,13 @@ function cmdReviews(args) {
       printJson({ ok: true, action: 'review_groups', projection_path: outPath, groups });
       return;
     }
-    console.log(`CERTIFIED REVIEW — grouped by ${key}`);
-    console.log(`${groups.total_certified} certified across ${groups.group_count} ${key} group(s)`);
+    console.log(`READY TO LAND — grouped by ${key}`);
+    console.log(`${groups.total_certified} ready to land across ${groups.group_count} ${key} group(s)`);
     groups.groups.forEach((g, index) => {
       console.log('');
       console.log(`${index + 1}. ${g.value} — ${g.count} task${g.count === 1 ? '' : 's'}`);
       g.sample_titles.forEach(title => console.log(`   • ${title}`));
-      console.log(`   review then accept the cluster: ${g.accept_group_command} --confirm-human-accept --as <you>`);
+      console.log(`   land this group: ${g.accept_group_command} --confirm-human-accept --as <you>`);
     });
     return;
   }
@@ -3988,10 +4195,10 @@ function cmdReviews(args) {
     });
     return;
   }
-  console.log('CERTIFIED REVIEW QUEUE');
-  console.log(`${queue.counts.certified} certified / ${queue.counts.blocking} need agent review / ${queue.counts.review} total review`);
+  console.log('READY TO LAND');
+  console.log(`${queue.counts.certified} ready to land / ${queue.counts.blocking} need one more check / ${queue.counts.review} total waiting`);
   if (!queue.items.length) {
-    console.log('No certified review items.');
+    console.log('Nothing is ready to land.');
     return;
   }
   queue.items.forEach((item, index) => {
@@ -4000,7 +4207,16 @@ function cmdReviews(args) {
     const badge = item.evidence?.all_passing ? ' [evidence:passing]' : '';
     console.log('');
     console.log(`${index + 1}. ${item.display_id || taskRef(item.id)}${tag}${passes}: ${item.title}${badge}`);
-    if (item.proof) console.log(`   proof: ${item.proof}`);
+    if (item.landing) {
+      console.log('   Result:');
+      if (item.landing.happened) console.log(`     What happened: ${item.landing.happened}`);
+      if (item.landing.reason) console.log(`     Why it matters: ${item.landing.reason}`);
+      if (item.landing.checked) console.log(`     How I checked: ${item.landing.checked}`);
+      if (item.landing.tested) console.log(`     What I tested: ${item.landing.tested}`);
+      if (item.result?.saved) console.log(`     Saved: ${item.result.saved}`);
+      if (item.landing.decision) console.log(`     Decision: ${item.landing.decision}`);
+    }
+    if (item.proof) console.log(`   details: ${item.proof}`);
     if (item.evidence) {
       item.evidence.receipts.forEach((receipt) => {
         const verdict = receipt.verifier_passed === true ? ' verifier:passed'
@@ -4011,9 +4227,9 @@ function cmdReviews(args) {
     }
     if (item.review_chat_command) console.log(`   /codex: ${item.review_chat_command}`);
     if (item.continue_work_command) console.log(`   continue: ${item.continue_work_command}`);
-    if (item.accept_command) console.log(`   accept: ${item.accept_command}`);
-    else if (item.blocked_accept_reason) console.log(`   accept: blocked (${item.blocked_accept_reason})`);
-    console.log(`   revise: ${item.revise_command}`);
+    if (item.accept_command) console.log(`   land: ${item.accept_command}`);
+    else if (item.blocked_accept_reason) console.log(`   land: blocked (${item.blocked_accept_reason})`);
+    console.log(`   send back: ${item.revise_command}`);
   });
   if (queue.counts.shown < queue.counts.certified) {
     console.log('');
@@ -4380,13 +4596,9 @@ function delegateHandoff(task, owner, via, tag) {
 function cmdDelegate(args) {
   const pos = positional(args);
   const title = pos.join(' ').trim();
-  const owner = flag(args, '--to') || flag(args, '--as');
   if (!title) {
     failTask('atris task delegate', 'missing_title', 'title required');
   }
-  if (!owner || owner === true) {
-    failTask('atris task delegate', 'missing_owner', '--to <owner> required');
-  }
   const viaFlag = flag(args, '--via');
   const via = viaFlag === 'swarlo' ? 'swarlo' : 'local';
   const tag = flag(args, '--tag');
@@ -4394,15 +4606,36 @@ function cmdDelegate(args) {
   const goalId = flag(args, '--goal-id');
   const goalObjective = flag(args, '--goal-objective') || flag(args, '--goal');
   const claimNow = hasFlag(args, '--claim');
+  const requestedOwner = flag(args, '--to') || flag(args, '--as');
+  const explicitExecutedBy = flag(args, '--executed-by');
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const ws = taskDb.workspaceRoot();
+  const ownerResolution = resolveFunctionalTaskOwner({
+    requestedOwner: requestedOwner && requestedOwner !== true ? requestedOwner : null,
+    title,
+    tag,
+    note,
+    goal: goalObjective && goalObjective !== true ? goalObjective : '',
+    root: ws,
+  });
+  const owner = ownerResolution.owner;
+  const executedBy = explicitExecutedBy && explicitExecutedBy !== true
+    ? normalizeOwnerSlug(explicitExecutedBy)
+    : ownerResolution.executed_by;
   const metadata = {
-    assigned_to: String(owner),
+    assigned_to: owner,
     delegate_via: via,
     swarlo_channel: via === 'swarlo' ? String(tag || 'tasks') : null,
     created_for_day: new Date().toISOString().slice(0, 10),
+    owner_resolution: ownerResolution.reason,
   };
+  if (ownerResolution.requested_owner) metadata.requested_owner = ownerResolution.requested_owner;
+  if (executedBy) metadata.executed_by = executedBy;
+  if (ownerResolution.proposed_member) {
+    metadata.proposed_member = ownerResolution.proposed_member;
+    metadata.proposed_member_command = `atris member create ${ownerResolution.proposed_member} --role="${ownerResolution.proposed_member.replace(/-/g, ' ')}"`;
+  }
   if (goalId && goalId !== true) metadata.goal_id = String(goalId);
   if (goalObjective && goalObjective !== true) {
     metadata.task_goal = String(goalObjective);
@@ -4413,7 +4646,7 @@ function cmdDelegate(args) {
     tag: typeof tag === 'string' ? tag : null,
     workspaceRoot: ws,
     status: claimNow ? 'claimed' : 'open',
-    claimedBy: claimNow ? String(owner) : null,
+    claimedBy: claimNow ? owner : null,
     metadata,
   });
   if (typeof note === 'string' && note.trim()) {
@@ -4421,14 +4654,16 @@ function cmdDelegate(args) {
   }
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
   const task = compactTaskFromProjection(projection, result.id);
-  const handoff = delegateHandoff(task, String(owner), via, typeof tag === 'string' ? tag : null);
+  const handoff = delegateHandoff(task, owner, via, typeof tag === 'string' ? tag : null);
   if (wantsJson(args)) {
     printJson({
       ok: true,
       action: 'delegated',
       task_id: result.id,
       inserted: result.inserted !== false,
-      owner: String(owner),
+      owner,
+      owner_resolution: ownerResolution,
+      executed_by: executedBy || null,
       via,
       handoff,
       projection_path: outPath,
@@ -4438,6 +4673,8 @@ function cmdDelegate(args) {
   }
   const tagText = tag && tag !== true ? ` #${tag}` : '';
   console.log(`delegated ${taskRef(task)} -> ${owner}${tagText} via=${via}`);
+  if (executedBy) console.log(`executed_by: ${executedBy}`);
+  if (ownerResolution.proposed_member) console.log(`member: ${metadata.proposed_member_command}`);
   console.log(`claim: ${handoff.command}`);
   if (handoff.swarlo) console.log(`swarlo: ${handoff.swarlo.channel}/${handoff.swarlo.action}`);
 }
@@ -4528,7 +4765,7 @@ function cmdDay(args) {
     console.log(`stale   ${staleFailed.length} failed >7d hidden — atris task list --status failed`);
   }
   console.log('');
-  console.log('add: atris task delegate "..." --to codex --tag tasks');
+  console.log('add: atris task delegate "..." --to task-planner --tag tasks');
 }
 
 function cmdHome(args) {
@@ -4784,7 +5021,7 @@ function cmdNext(args) {
         }
         console.log(`created ${taskRef(createdTask)} @${owner}`);
         console.log(createdTask.title);
-        console.log(`Noted v${created.note_version}. Human accept remains pending on ${taskRef(reviewTask)}.`);
+        console.log(`Noted v${created.note_version}. Landing remains pending on ${taskRef(reviewTask)}.`);
         console.log(`Verify: ${nextAgentAction.task_seed.verifier}`);
         return;
       }
@@ -4805,12 +5042,12 @@ function cmdNext(args) {
       }
       console.log('No open tasks.');
       console.log(handoff.next_action === 'agent_review_again'
-        ? `${taskRef(reviewTask)} needs one more agent review before continuation.`
-        : `${taskRef(reviewTask)} is agent-certified and waiting for human accept.`);
+        ? `${taskRef(reviewTask)} needs one more agent check before landing.`
+        : `${taskRef(reviewTask)} is ready to land.`);
       console.log(handoff.next_action === 'continue_work'
-        ? 'Continue work elsewhere; AgentXP waits for human accept.'
+        ? 'Continue work elsewhere; XP lands after the human lands this task.'
         : handoff.next_action === 'human_accept_waiting'
-        ? (nextAgentAction ? nextAgentAction.message : 'No concrete next agent task is attached; AgentXP waits for human accept.')
+        ? (nextAgentAction ? nextAgentAction.message : 'No next agent task is attached; this task is ready to land when the human decides.')
         : 'Review this task again before continuing.');
       if (nextAgentAction) console.log(`Command: ${nextAgentAction.command}`);
       if (nextAgentAction && nextAgentAction.task_seed) {
@@ -5221,17 +5458,30 @@ function cmdShow(args) {
   }
   const owner = task.claimed_by ? ` / ${task.claimed_by}` : '';
   const tag = task.tag ? ` #${task.tag}` : '';
-  console.log(`${task.status.toUpperCase()} ${taskRef(task)} v${task.current_version}${owner}${tag}`);
+  const statusLabel = task.status === 'review'
+    ? 'READY TO LAND'
+    : task.status === 'done'
+      ? 'LANDED'
+      : task.status.toUpperCase();
+  console.log(`${statusLabel} ${taskRef(task)} v${task.current_version}${owner}${tag}`);
   console.log(task.title);
   if (task.review) {
     console.log('');
-    if (task.review.summary) console.log(`Summary: ${task.review.summary}`);
-    if (task.review.proof) console.log(`Proof: ${task.review.proof}`);
+    printReviewLanding(task.review);
+    if (task.review.summary) console.log(`Short version: ${task.review.summary}`);
+    if (task.review.proof) console.log(`Details: ${task.review.proof}`);
     if (task.review.lesson) console.log(`Lesson: ${task.review.lesson}`);
     if (task.review.next_task) console.log(`Next: ${task.review.next_task}`);
-    if (task.review.approval_status) console.log(`Approval: ${task.review.approval_status}`);
-    if (task.review.verification_chat) console.log(`Review chat: ${task.review.verification_chat.command}`);
-    if (task.review.agent_certified) console.log(`Agent certified: yes (${task.review.agent_review_pass_count || AGENT_CERTIFICATION_REVIEW_PASSES} reviews)`);
+    if (task.review.approval_status) {
+      const landingStatus = task.review.approval_status === 'pending'
+        ? 'waiting on human'
+        : task.review.approval_status === 'revise'
+          ? 'sent back'
+          : task.review.approval_status;
+      console.log(`Landing: ${landingStatus}`);
+    }
+    if (task.review.verification_chat) console.log(`Check command: ${task.review.verification_chat.command}`);
+    if (task.review.agent_certified) console.log(`Checked: yes (${task.review.agent_review_pass_count || AGENT_CERTIFICATION_REVIEW_PASSES} agent checks)`);
   }
   if (task.messages.length) {
     console.log('');
@@ -5273,10 +5523,11 @@ function cmdPage(args) {
   console.log(`TASK PAGE ${taskRef(task)}`);
   console.log(`Goal: ${page.goal.text || '(none)'}`);
   console.log(`Stage: ${page.stage.current}`);
+  printReviewLanding(page.review);
   console.log(`Next: ${page.stage.next_action.command || page.stage.next_action.label}`);
   console.log(`Chat: ${page.chat.command}`);
-  if (page.review.verification_chat) console.log(`Review chat: ${page.review.verification_chat.command}`);
-  if (page.review.human_accept.enabled) console.log(`Human accept: ${page.review.human_accept.command}`);
+  if (page.review.verification_chat) console.log(`Check command: ${page.review.verification_chat.command}`);
+  if (page.review.human_accept.enabled) console.log(`Land: ${page.review.human_accept.command}`);
 }
 
 function cmdReviewChat(args) {
@@ -6013,7 +6264,7 @@ function taskPageActions(task, { reviewer = 'codex-review', hasExistingReviewFol
     note_command: `atris task note ${ref} "<context>" --as ${owner}`,
     plan_command: `atris task plan ${ref} --goal ${taskCommandQuote(goal)} --exit "<exit condition>" --proof-needed "<verification command>" --first-move "<first move>"`,
     do_command: `atris task do ${ref} --as ${owner} --first-move "<first move>"`,
-    ready_command: `atris task ready ${ref} --as ${owner} --proof "<specific proof command/result>"`,
+    ready_command: `atris task ready ${ref} --as ${owner} --proof "<specific proof command/result>" --happened "<what happened>" --checked "<how you know>" --tested "<what you ran or inspected>" --decision "<accept/rework guidance>"`,
     review_command: `atris task review ${ref} --reward 0 --as ${actor} --proof "<specific proof command/result>" --verify "<safe verifier command>"`,
   };
   if (task && task.status === 'review') {
@@ -6071,7 +6322,7 @@ function taskPageNextAction(task, current, actions, { hasExistingReviewFollowUp
     if (handoff && handoff.next_action === 'human_accept_waiting') {
       return {
         key: 'human_accept_waiting',
-        label: 'Waiting for human accept',
+        label: 'Ready to land',
         command: null,
         api: null,
         human_accept_command: actions.human_accept_command || null,
@@ -6092,6 +6343,7 @@ function taskPageContract(task, { reviewer = 'codex-review', hasExistingReviewFo
   const metadata = task && task.metadata || {};
   const current = taskPageCurrentStage(task);
   const actions = taskPageActions(task, { reviewer, hasExistingReviewFollowUp });
+  const review = task && (task.review || taskReviewSummary(task));
   const recentMessages = (task && Array.isArray(task.messages) ? task.messages : []).slice(-10).map(message => ({
     version: message.version || null,
     actor: message.actor || null,
@@ -6135,9 +6387,13 @@ function taskPageContract(task, { reviewer = 'codex-review', hasExistingReviewFo
     },
     actions,
     review: {
-      approval_status: task.review && task.review.approval_status || metadata.approval_status || null,
-      agent_review_pass_count: task.review && task.review.agent_review_pass_count || metadata.agent_review_pass_count || null,
-      agent_certified: Boolean(task.review && task.review.agent_certified || metadata.agent_certified),
+      landing: review && review.landing || null,
+      result: review && review.result || null,
+      summary: review && review.summary || null,
+      proof: review && review.proof || null,
+      approval_status: review && review.approval_status || metadata.approval_status || null,
+      agent_review_pass_count: review && review.agent_review_pass_count || metadata.agent_review_pass_count || null,
+      agent_certified: Boolean(review && review.agent_certified || metadata.agent_certified),
       verification_chat: reviewChat,
       handoff: reviewHandoff,
       human_accept: {
@@ -6188,7 +6444,7 @@ function appendTaskReviewChat(taskDb, db, taskId, { reviewer = 'codex-review', d
     throw taskReviewChatError(`not_reviewable_${task.status}`, `review chat requires a task in Review; current status is ${task.status}`, { status: 409, exitCode: 1 });
   }
   if (!taskAllowsReviewChat(task, { allowCertified: true })) {
-    throw taskReviewChatError('agent_certified_continue_work', 'review chat is closed after agent certification; continue other work or wait for human accept', { status: 409, exitCode: 1 });
+    throw taskReviewChatError('agent_certified_continue_work', 'review chat is closed after agent certification; continue other work or land/send back this task', { status: 409, exitCode: 1 });
   }
   const contract = taskReviewChatContract(task, { reviewer: actor, allowCertified: true });
   let event = null;
@@ -6345,8 +6601,8 @@ function readyHandoffForStep(task, proof, lesson, nextTask, agentCertified) {
     career_xp_status: 'pending_human_accept',
     next_action: agentCertified ? certifiedReviewNextAction(nextTask) : 'agent_review_again',
     rule: agentCertified
-      ? 'Agent double-check complete; continue work. AgentXP waits for human accept.'
-      : 'Proof is in Review; one more agent review pass certifies continuation. AgentXP waits for human accept.',
+      ? 'Double-check complete; ready to keep moving. XP lands only after the human lands the task.'
+      : 'Proof is ready; one more agent check before landing. XP waits for the human.',
   };
   if (reviewChat) {
     handoff.review_chat_command = reviewChat.command;
@@ -6367,7 +6623,7 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
     const reason = initialHandoffState.next_action === 'continue_work'
       ? 'agent_certified_continue_work'
       : 'agent_certified_waiting_human';
-    throw taskStepError(reason, 'atris task step: agent-certified Review rows have no safe agent step; continue other work or wait for human accept', { status: 409, exitCode: 1, page: initialPage });
+    throw taskStepError(reason, 'atris task step: ready-to-land rows have no safe agent step; continue other work or land/send back this task', { status: 409, exitCode: 1, page: initialPage });
   }
   let chat = null;
   const message = String(options.message || '').trim();
@@ -6469,7 +6725,7 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
       const reason = handoffState.next_action === 'continue_work'
         ? 'agent_certified_continue_work'
         : 'agent_certified_waiting_human';
-      throw taskStepError(reason, 'atris task step: agent-certified Review rows have no safe agent step; continue other work or wait for human accept', { status: 409, exitCode: 1, page: actionPage });
+      throw taskStepError(reason, 'atris task step: ready-to-land rows have no safe agent step; continue other work or land/send back this task', { status: 409, exitCode: 1, page: actionPage });
     }
     const reviewed = appendTaskReviewChat(taskDb, db, taskId, { reviewer, dryRun: Boolean(options.dryRun) });
     stepAction = 'review_chat';
@@ -6577,7 +6833,7 @@ function runCurrentTaskStep(taskDb, db, { owner = DEFAULT_OWNER, reviewer = 'cod
   if (nextActionKey === 'human_accept_waiting') {
     const error = taskStepError(
       'agent_certified_waiting_human',
-      'atris task current-step: selected Review row is agent-certified and waiting for human accept; no agent mutation is safe',
+      'atris task current-step: selected row is ready to land; no agent mutation is safe',
       {
         status: 409,
         exitCode: 1,
@@ -6989,6 +7245,7 @@ function cmdReady(args) {
   requireMeaningfulTaskProof('atris task ready', proof);
   const lesson = flag(args, '--lesson') || '';
   const nextTaskInput = normalizeReviewNextTaskInput(typeof flag(args, '--next') === 'string' ? flag(args, '--next') : '');
+  const landing = landingFlags(args);
   const actor = String(flag(args, '--as') || DEFAULT_OWNER);
   const resultFields = {
     changed: textFlag(args, ['--changed', '--result', '--done']),
@@ -7017,6 +7274,7 @@ function cmdReady(args) {
     lesson: typeof lesson === 'string' ? lesson : '',
     nextTask: nextTaskInput.nextTask,
     resultTrace: resultTrace && resultTrace.trace,
+    landing,
   });
   if (!result.ready) {
     console.error(`ready failed: ${result.reason}`);
@@ -7038,8 +7296,8 @@ function cmdReady(args) {
     career_xp_status: 'pending_human_accept',
     next_action: agentCertified ? certifiedReviewNextAction(nextTaskInput.nextTask) : 'agent_review_again',
     rule: agentCertified
-      ? 'Agent double-check complete; continue work. AgentXP waits for human accept.'
-      : 'Proof is in Review; one more agent review pass certifies continuation. AgentXP waits for human accept.',
+      ? 'Double-check complete; ready to keep moving. XP lands only after the human lands the task.'
+      : 'Proof is ready; one more agent check before landing. XP waits for the human.',
   };
   if (reviewChat) {
     handoff.review_chat_command = reviewChat.command;
@@ -7069,7 +7327,7 @@ function cmdReady(args) {
     });
     return;
   }
-  console.log(`ready ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version} pending approval`);
+  console.log(`ready to land ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version}`);
   if (resultTrace) console.log('Result trace recorded.');
   console.log(handoff.rule);
   for (const hint of policyHints) {
@@ -7361,6 +7619,7 @@ function cmdRevise(args) {
       version: result.event.version,
       approval_status: 'revise',
       revision_count: result.event.payload.revision_count,
+      episode: result.episode || null,
       projection_path: outPath,
       task: compactTaskFromProjection(projection, taskId),
     });
@@ -8288,7 +8547,10 @@ function taskBoardHtml() {
         '<div class="meta"><span class="pill">' + task.status + '</span><span class="pill">' + (task.claimed_by || 'unowned') + '</span><span class="pill">v' + task.current_version + '</span></div>',
         '<div class="fact"><b>Goal</b><div id="taskGoal"></div></div>',
         '<div class="fact"><b>Lineage</b><div id="taskLineage"></div></div>',
-        '<div class="fact"><b>Summary</b><div id="taskSummary"></div></div>',
+        '<div class="fact"><b>Result</b><div id="taskHappened"></div></div>',
+        '<div class="fact"><b>How I checked</b><div id="taskChecked"></div></div>',
+        '<div class="fact"><b>What I tested</b><div id="taskTested"></div></div>',
+        '<div class="fact"><b>Decision</b><div id="taskDecision"></div></div>',
         '<div class="fact"><b>Proof / lesson</b><div id="taskProof"></div></div>',
         '<div class="thread">' + (messages || '<div class="empty">No thread yet.</div>') + '</div>',
         '<label>Add context</label><textarea id="note" placeholder="Decision, blocker, context, update..."></textarea>',
@@ -8300,9 +8562,17 @@ function taskBoardHtml() {
       room.querySelector('h3').textContent = task.title;
       $('taskGoal').textContent = task.objective || 'No matching goal yet.';
       $('taskLineage').textContent = 'parent: ' + parent + ' / next: ' + children;
-      $('taskSummary').textContent = task.review && task.review.summary
-        ? task.review.summary
-        : 'No review summary yet.';
+      const result = task.review && task.review.result || {};
+      const landing = task.review && task.review.landing || {
+        happened: result.changed,
+        checked: result.checked,
+        tested: task.review && task.review.proof ? 'Proof is attached below.' : '',
+        decision: result.accept,
+      };
+      $('taskHappened').textContent = landing.happened || (task.review && task.review.summary) || 'No review result yet.';
+      $('taskChecked').textContent = landing.checked || 'No check yet.';
+      $('taskTested').textContent = landing.tested || 'No test recorded yet.';
+      $('taskDecision').textContent = landing.decision || 'No accept action yet.';
       $('taskProof').textContent = task.review && (task.review.proof || task.review.lesson)
         ? ((task.review.proof || 'no proof') + ' / ' + (task.review.lesson || 'no lesson'))
         : 'No proof yet.';
@@ -8804,6 +9074,12 @@ async function handleTaskApi(req, res, taskDb, db) {
       lesson: String(body.lesson || ''),
       nextTask: nextTaskInput.nextTask,
       resultTrace: resultTrace && resultTrace.trace,
+      landing: body.landing || {
+        happened: body.happened,
+        checked: body.checked,
+        tested: body.tested,
+        decision: body.decision,
+      },
     });
     if (!result.ready) return sendJson(res, 409, { ok: false, reason: result.reason });
     const { projection, outPath } = writeDefaultProjection(taskDb, db);