atris 3.30.0 → 3.30.2

package/commands/task.js

@@ -11,12 +11,17 @@ 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
   || os.userInfo().username
   || 'unknown';
 const AGENT_CERTIFICATION_REVIEW_PASSES = 2;
+const RESULT_SAVED_TEXT_LIMIT = 200;
 const REVIEW_LANE_LOOP_DEFAULT_MAX_STEPS = 3;
 const REVIEW_LANE_LOOP_MAX_STEPS = 10;
 const REVIEW_LANE_RUN_DEFAULT_MAX_RUNS = 3;
@@ -97,14 +102,23 @@ atris task - durable local task state (SQLite, gitignored)
   atris task chat <id> "<message>" [--goal "..."]  Refine a task chat + working goal
   atris task ready <id> --proof "..."      Agent proof ready; native goal can complete
   atris task ready <id> --verify "<cmd>"   Run <cmd>; only ready if it exits 0 (executed proof)
+  atris task plan-preview "<purpose>" [--tag <tag>] [--owner <member>] [--task <id>]
+                                           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
-  atris task accept <id> [--proof "..."]   Human accepts proof, marks done
+  atris task accept <id> [--proof "..."] [--public]
+                                           Human accepts proof, marks done; --public also publishes AgentXP
   atris task auto-accept-certified --dry-run [--strict-verify] [--limit <n>]
                                            Preview certified Review rows; live accept needs --confirm-human-accept --as <human>
   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 "..."
@@ -137,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
@@ -301,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;
@@ -637,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,
@@ -651,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) {
@@ -673,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,
@@ -685,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
@@ -705,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'),
@@ -718,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) {
@@ -943,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}`);
@@ -956,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');
@@ -1373,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);
@@ -1396,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;
@@ -1590,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;
@@ -2674,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: [],
@@ -2695,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' };
@@ -3813,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;
@@ -3960,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;
   }
@@ -3980,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) => {
@@ -3992,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'
@@ -4003,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('');
@@ -4372,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');
@@ -4386,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);
@@ -4405,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()) {
@@ -4413,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,
@@ -4430,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}`);
 }
@@ -4520,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) {
@@ -4776,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;
       }
@@ -4797,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) {
@@ -5021,7 +5266,8 @@ function cmdPlan(args) {
   const pos = positional(args);
   const id = pos[0];
   if (!id) failTask('atris task plan', 'missing_id', 'id required');
-  const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+  const actorFlag = flag(args, '--as');
+  const actor = String(actorFlag || DEFAULT_OWNER);
   const goal = textFlag(args, ['--goal', '--objective']);
   const exit = textFlag(args, ['--exit', '--exit-condition']);
   const proofNeeded = textFlag(args, ['--proof-needed', '--proof', '--verify']);
@@ -5033,18 +5279,29 @@ function cmdPlan(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, id, 'atris task plan');
+  const task = taskDetail(taskDb, db, taskId);
+  const automaticPlan = buildAutomaticPlanTrace(taskDb, task, {
+    actor,
+    actorExplicit: typeof actorFlag === 'string' && Boolean(actorFlag.trim()),
+    owner,
+    goal,
+    summary,
+    firstMove,
+    exit,
+  });
   const result = taskDb.stageTask(db, {
     id: taskId,
     actor,
     stage: 'plan',
     goal,
     summary,
-    owner,
+    owner: automaticPlan.ownerForStage || owner,
     exit,
     proofNeeded,
     firstMove,
     nextButton,
     confidence,
+    planTrace: automaticPlan.trace,
   });
   if (!result.staged) {
     failTask('atris task plan', result.reason || 'stage_failed', stageErrorDetail('atris task plan', result.reason, result), 1);
@@ -5056,6 +5313,11 @@ function cmdPlan(args) {
       action: 'planned',
       task_id: taskId,
       version: result.event.version,
+      plan_trace: automaticPlan.trace ? {
+        plan: automaticPlan.plan,
+        owner_choice: automaticPlan.ownerChoice,
+        trace: automaticPlan.trace,
+      } : null,
       stage_packet: result.stage_packet,
       projection_path: outPath,
       task: compactTaskFromProjection(projection, taskId),
@@ -5196,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('');
@@ -5248,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) {
@@ -5320,6 +5596,611 @@ function taskCommandQuote(value) {
   return `"${text || '...'}"`;
 }
 
+function cleanPublicText(value, max = 500) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > max ? `${text.slice(0, Math.max(0, max - 3)).trim()}...` : text;
+}
+
+function publicWords(value) {
+  return (String(value || '').toLowerCase().match(/[a-z0-9]{3,}/g) || [])
+    .map(word => word.endsWith('s') && word.length > 4 ? word.slice(0, -1) : word)
+    .filter(word => !new Set([
+      'and',
+      'for',
+      'from',
+      'into',
+      'the',
+      'this',
+      'that',
+      'task',
+      'work',
+      'with',
+    ]).has(word));
+}
+
+function parseMemberFrontmatter(text) {
+  const source = String(text || '');
+  if (!source.startsWith('---')) return {};
+  const end = source.indexOf('\n---', 3);
+  if (end === -1) return {};
+  const block = source.slice(3, end).split(/\r?\n/);
+  const data = {};
+  for (const raw of block) {
+    const match = raw.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) continue;
+    data[match[1]] = match[2].replace(/^["']|["']$/g, '').trim();
+  }
+  return data;
+}
+
+function readTeamMembers(root = process.cwd()) {
+  const teamDir = path.join(root, 'atris', 'team');
+  if (!fs.existsSync(teamDir)) return [];
+  return fs.readdirSync(teamDir, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => {
+      const slug = entry.name;
+      const memberPath = path.join(teamDir, slug, 'MEMBER.md');
+      if (!fs.existsSync(memberPath)) return null;
+      const text = fs.readFileSync(memberPath, 'utf8');
+      const frontmatter = parseMemberFrontmatter(text);
+      return {
+        slug,
+        role: cleanPublicText(frontmatter.role || slug.replace(/[-_]/g, ' '), 120),
+        description: cleanPublicText(frontmatter.description || '', 240),
+        path: memberPath,
+      };
+    })
+    .filter(Boolean);
+}
+
+const GENERIC_MEMBER_SLUGS = new Set([
+  '_template',
+  'coordinator',
+  'executor',
+  'generalist',
+  'navigator',
+  'supervisor',
+]);
+
+function scoreTeamMember(member, words, tag) {
+  const slug = String(member.slug || '').toLowerCase();
+  const role = String(member.role || '').toLowerCase();
+  const description = String(member.description || '').toLowerCase();
+  const haystack = `${slug} ${role} ${description}`.replace(/[-_]/g, ' ');
+  let score = 0;
+  const cleanTag = String(tag || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+  if (cleanTag) {
+    if (slug === cleanTag || slug.replace(/[-_]/g, ' ') === cleanTag) score += 12;
+    else if (haystack.includes(cleanTag)) score += 5;
+  }
+  for (const word of words) {
+    if (slug.includes(word)) score += 5;
+    else if (role.includes(word)) score += 3;
+    else if (description.includes(word)) score += 2;
+  }
+  if (GENERIC_MEMBER_SLUGS.has(slug)) score -= 3;
+  return score;
+}
+
+function plainMemberDescription(member) {
+  const description = cleanPublicText(member && member.description, 220);
+  if (!description) return '';
+  const lowered = `${description.charAt(0).toLowerCase()}${description.slice(1)}`;
+  return /[.!?]$/.test(lowered) ? lowered : `${lowered}.`;
+}
+
+function chooseTaskOwner({ purpose, tag, requestedOwner, root = process.cwd() } = {}) {
+  const members = readTeamMembers(root);
+  const requested = cleanPublicText(requestedOwner, 80);
+  if (requested) {
+    const match = members.find(member => member.slug === requested);
+    if (match) {
+      const description = plainMemberDescription(match);
+      return {
+        owner: match.slug,
+        member: match,
+        source: 'requested',
+        reason: `${match.slug} matches this work${description ? ` because ${description}` : '.'}`,
+      };
+    }
+    return {
+      owner: requested,
+      member: null,
+      source: 'requested',
+      reason: `${requested} was requested, but no matching atris/team member was found.`,
+    };
+  }
+  const words = publicWords(`${purpose || ''} ${tag || ''}`);
+  let best = null;
+  for (const member of members) {
+    const score = scoreTeamMember(member, words, tag);
+    if (!best || score > best.score) best = { member, score };
+  }
+  if (best && best.score > 0) {
+    const member = best.member;
+    const description = plainMemberDescription(member);
+    return {
+      owner: member.slug,
+      member,
+      source: 'team',
+      score: best.score,
+      reason: `${member.slug} fits this work${description ? ` because ${description}` : '.'}`,
+    };
+  }
+  return {
+    owner: DEFAULT_OWNER,
+    member: null,
+    source: 'fallback',
+    reason: `${DEFAULT_OWNER} is handling it because no specific atris/team owner matched this work.`,
+  };
+}
+
+function isGenericPlanActor(value) {
+  const actor = cleanPublicText(value, 80).toLowerCase();
+  if (!actor) return true;
+  if (actor === String(DEFAULT_OWNER || '').toLowerCase()) return true;
+  return GENERIC_MEMBER_SLUGS.has(actor) || new Set([
+    'codex',
+    'codex-executor',
+    'claude',
+    'claude-code',
+    'cursor',
+    'devin',
+  ]).has(actor);
+}
+
+function taskTextMentionsActor(actor, text) {
+  const actorWords = publicWords(actor);
+  if (!actorWords.length) return false;
+  const words = new Set(publicWords(text));
+  return actorWords.some(word => words.has(word));
+}
+
+function buildPublicPlan({ purpose, owner, ownerReason, plan, expected }) {
+  const cleanPurpose = cleanPublicText(purpose, 240);
+  const cleanOwner = cleanPublicText(owner, 80);
+  const cleanReason = cleanPublicText(ownerReason, 240);
+  const cleanPlan = cleanPublicText(plan, 320) || `${cleanOwner || 'The owner'} will make the smallest needed change, then check the result.`;
+  const cleanExpected = cleanPublicText(expected, 240) || 'the check passes and the result is ready to review.';
+  return {
+    purpose: cleanPurpose,
+    owner: cleanOwner,
+    owner_reason: cleanReason,
+    plan: cleanPlan,
+    expected_result: cleanExpected,
+  };
+}
+
+function renderPublicPlan(plan) {
+  const lines = [];
+  if (plan.purpose) lines.push(`Purpose: ${plan.purpose}`);
+  if (plan.owner) lines.push(`Owner: ${plan.owner} is handling it.`);
+  if (plan.owner_reason) lines.push(`Why: ${plan.owner_reason}`);
+  if (plan.plan) lines.push(`Plan: ${plan.plan}`);
+  if (plan.expected_result) lines.push(`Expected result: ${plan.expected_result}`);
+  return lines.join('\n');
+}
+
+function planTraceData(plan, ownerChoice) {
+  return {
+    schema: 'atris.task_plan_trace.v1',
+    purpose: plan.purpose,
+    owner: plan.owner,
+    owner_reason: plan.owner_reason,
+    plan: plan.plan,
+    expected_result: plan.expected_result,
+    owner_source: ownerChoice && ownerChoice.source || null,
+    owner_score: ownerChoice && ownerChoice.score || null,
+    recorded_at: new Date().toISOString(),
+  };
+}
+
+function planTraceNote(plan, ownerChoice) {
+  return `TASK_PLAN_TRACE ${JSON.stringify(planTraceData(plan, ownerChoice))}`;
+}
+
+function traceLineFromContent(content, prefix) {
+  const lines = String(content || '').split(/\r?\n/);
+  return lines.find(line => line.startsWith(prefix)) || '';
+}
+
+function latestTraceValue(task, prefix, key) {
+  const messages = Array.isArray(task && task.messages) ? task.messages : [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const content = String(messages[i] && messages[i].content || '');
+    const line = traceLineFromContent(content, prefix);
+    if (!line) continue;
+    try {
+      const parsed = JSON.parse(line.slice(prefix.length).trim());
+      const value = parsed && parsed[key];
+      if (value !== undefined && value !== null && String(value).trim()) return String(value);
+    } catch (_) {
+      continue;
+    }
+  }
+  return '';
+}
+
+function taskHasTrace(task, prefix) {
+  const messages = Array.isArray(task && task.messages) ? task.messages : [];
+  if (messages.some(message => traceLineFromContent(message && message.content, prefix))) return true;
+  const events = Array.isArray(task && task.events) ? task.events : [];
+  return events.some(event => {
+    const payload = event && event.payload && typeof event.payload === 'object' ? event.payload : {};
+    if (traceLineFromContent(payload.stage_packet, prefix)) return true;
+    if (traceLineFromContent(payload.result_packet, prefix)) return true;
+    if (prefix === 'TASK_RESULT_TRACE ' && payload.result_trace && typeof payload.result_trace === 'object') return true;
+    if (prefix === 'TASK_PLAN_TRACE ' && payload.plan_trace && typeof payload.plan_trace === 'object') return true;
+    return false;
+  });
+}
+
+function taskPurpose(task) {
+  const metadata = task && task.metadata || {};
+  return cleanPublicText(
+    metadata.task_goal
+      || metadata.goal_objective
+      || metadata.objective
+      || metadata.stage_goal
+      || latestTraceValue(task, 'TASK_PLAN_TRACE ', 'purpose')
+      || task && task.title
+      || '',
+    240,
+  );
+}
+
+function buildPublicResult(task, fields) {
+  const owner = cleanPublicText(
+    fields.owner
+      || latestTraceValue(task, 'TASK_PLAN_TRACE ', 'owner')
+      || taskAssignee(task)
+      || task && task.claimed_by
+      || fields.actor,
+    80,
+  );
+  const result = {
+    purpose: cleanPublicText(fields.purpose || taskPurpose(task), 240),
+    owner,
+    changed: cleanPublicText(fields.changed, 320),
+    checked: cleanPublicText(fields.checked, 320),
+    passed: cleanPublicText(fields.passed, 240),
+    failed: cleanPublicText(fields.failed, 240),
+    cost: cleanPublicText(fields.cost, 80),
+    saved: cleanPublicText(fields.saved, RESULT_SAVED_TEXT_LIMIT),
+    try_next: cleanPublicText(fields.tryNext, 240),
+    status: cleanPublicText(fields.status, 160) || 'ready for review',
+  };
+  return result;
+}
+
+function renderPublicResult(result) {
+  return [
+    `Changed: ${cleanPublicText(result && result.changed, 320) || 'changed the requested work'}`,
+    `Checked: ${cleanPublicText(result && result.checked, 320) || 'checked the result'}`,
+    `Try: ${cleanPublicText(result && result.try_next, 240) || 'try the changed work'}`,
+  ].join('\n');
+}
+
+function latestResultTrace(task) {
+  const messages = Array.isArray(task && task.messages) ? task.messages : [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const content = String(messages[i] && messages[i].content || '');
+    const line = traceLineFromContent(content, 'TASK_RESULT_TRACE ');
+    if (!line) continue;
+    try {
+      const parsed = JSON.parse(line.slice('TASK_RESULT_TRACE '.length).trim());
+      if (parsed && typeof parsed === 'object') return parsed;
+    } catch (_) {}
+  }
+
+  const events = Array.isArray(task && task.events) ? task.events : [];
+  for (let i = events.length - 1; i >= 0; i--) {
+    const payload = events[i] && events[i].payload && typeof events[i].payload === 'object'
+      ? events[i].payload
+      : {};
+    if (payload.result_trace && typeof payload.result_trace === 'object') return payload.result_trace;
+    const packetLine = traceLineFromContent(payload.result_packet, 'TASK_RESULT_TRACE ');
+    if (!packetLine) continue;
+    try {
+      const parsed = JSON.parse(packetLine.slice('TASK_RESULT_TRACE '.length).trim());
+      if (parsed && typeof parsed === 'object') return parsed;
+    } catch (_) {}
+  }
+  return null;
+}
+
+function buildAcceptHumanResult({ task, proof, nextTask, publicSync }) {
+  const trace = latestResultTrace(task) || {};
+  const traceChanged = cleanPublicText(trace.changed, 320);
+  const changed = traceChanged === 'prepared the work for review'
+    ? 'accepted the completed work'
+    : traceChanged
+    || cleanPublicText(task && task.title, 260)
+    || 'accepted the completed work';
+  let checked = cleanPublicText(trace.checked, 320)
+    || cleanPublicText(proof, 320)
+    || 'checked the proof';
+  if (publicSync && publicSync.enabled === true && !publicSync.ok) {
+    const error = cleanPublicText(publicSync.error || 'publish failed', 140);
+    checked = `${checked}; AgentXP publish failed${error ? ` (${error})` : ''}`;
+  }
+  const tryNext = cleanPublicText(nextTask, 240)
+    || cleanPublicText(trace.try_next, 240)
+    || 'try the changed work';
+  return { changed, checked, try_next: tryNext };
+}
+
+function renderAcceptLanding({ task, proof, nextTask, publicSync }) {
+  return renderPublicResult(buildAcceptHumanResult({
+    task,
+    proof,
+    nextTask,
+    publicSync,
+  }));
+}
+
+async function publishAcceptAgentXp(args, actor) {
+  const token = flag(args, '--token');
+  const syncArgs = ['--all', '--root', process.cwd(), '--public', '--as', actor];
+  if (typeof token === 'string' && token.trim()) syncArgs.push('--token', token.trim());
+  try {
+    const { syncAgentXp } = require('../commands/xp');
+    const result = await syncAgentXp(syncArgs);
+    const server = result && result.server ? result.server : {};
+    const publicCount = Number(server.public_accepted_count);
+    const acceptedCount = Number(server.accepted_count);
+    const published = (
+      (Number.isFinite(publicCount) && publicCount > 0)
+      || (Number.isFinite(acceptedCount) && acceptedCount > 0 && server.private_agentxp !== true)
+    );
+    return {
+      enabled: true,
+      ok: published,
+      result,
+      error: published ? null : 'server accepted no public AgentXP rows',
+    };
+  } catch (error) {
+    return {
+      enabled: true,
+      ok: false,
+      error: error && error.message ? error.message : String(error),
+    };
+  }
+}
+
+function todayResultLogName() {
+  const now = new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}.md`;
+}
+
+function appendResultOwnerLog(root, task, result) {
+  const owner = cleanPublicText(result && result.owner, 80);
+  if (!owner || !/^[A-Za-z0-9._-]+$/.test(owner)) return null;
+  const memberFile = path.join(root, 'atris', 'team', owner, 'MEMBER.md');
+  if (!fs.existsSync(memberFile)) return null;
+  const logName = todayResultLogName();
+  const logDir = path.join(root, 'atris', 'team', owner, 'logs');
+  fs.mkdirSync(logDir, { recursive: true });
+  const logPath = path.join(logDir, logName);
+  const stamp = new Date().toTimeString().slice(0, 5);
+  const lines = [
+    `## ${stamp} - Result`,
+    `- task: ${taskRef(task)}`,
+    `- purpose: ${result.purpose || ''}`,
+    `- result: ${result.changed || ''}`,
+    `- checked: ${result.checked || ''}`,
+    `- saved: ${result.saved || ''}`,
+    `- try: ${result.try_next || ''}`,
+    `- status: ${result.status || ''}`,
+    '',
+  ];
+  fs.appendFileSync(logPath, lines.join('\n'), 'utf8');
+  return {
+    member_log_path: path.relative(root, logPath),
+  };
+}
+
+function resultTraceData(result, fields) {
+  return {
+    schema: 'atris.task_result_trace.v1',
+    purpose: result.purpose,
+    owner: result.owner || null,
+    changed: result.changed,
+    checked: result.checked,
+    passed: result.passed || null,
+    failed: result.failed || null,
+    cost: result.cost || null,
+    saved: result.saved || null,
+    try_next: result.try_next || null,
+    status: result.status,
+    files: cleanPublicText(fields.files, 500) || null,
+    commands: cleanPublicText(fields.commands, 500) || null,
+    member_log_path: fields.savedPaths && fields.savedPaths.member_log_path || null,
+    recorded_at: new Date().toISOString(),
+  };
+}
+
+function resultTraceNote(result, fields) {
+  return `TASK_RESULT_TRACE ${JSON.stringify(resultTraceData(result, fields))}`;
+}
+
+function cmdPlanPreview(args) {
+  const pos = positional(args);
+  const purpose = cleanPublicText(textFlag(args, ['--purpose', '--goal', '--objective']) || pos.join(' '), 240);
+  if (!purpose) failTask('atris task plan-preview', 'missing_purpose', 'purpose required');
+  const tag = textFlag(args, ['--tag']);
+  const requestedOwner = textFlag(args, ['--owner', '--as', '--member']);
+  const planText = textFlag(args, ['--plan', '--action', '--first-move']);
+  const expected = textFlag(args, ['--expected', '--expected-result', '--exit']);
+  const recordRef = textFlag(args, ['--task', '--record']);
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const ownerChoice = chooseTaskOwner({
+    purpose,
+    tag,
+    requestedOwner,
+    root: taskDb.workspaceRoot(),
+  });
+  const publicPlan = buildPublicPlan({
+    purpose,
+    owner: ownerChoice.owner,
+    ownerReason: ownerChoice.reason,
+    plan: planText,
+    expected,
+  });
+  let recorded = null;
+  if (recordRef) {
+    const taskId = requireTaskId(taskDb, db, recordRef, 'atris task plan-preview');
+    const note = taskDb.noteTask(db, {
+      id: taskId,
+      actor: publicPlan.owner || DEFAULT_OWNER,
+      content: planTraceNote(publicPlan, ownerChoice),
+    });
+    if (!note.noted) failTask('atris task plan-preview', note.reason || 'note_failed', `plan-preview failed: ${note.reason || 'note_failed'}`, 1);
+    const { outPath } = writeDefaultProjection(taskDb, db);
+    recorded = {
+      task_id: taskId,
+      version: note.event.version,
+      projection_path: outPath,
+    };
+  }
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'plan_preview',
+      plan: publicPlan,
+      owner_choice: {
+        owner: ownerChoice.owner,
+        source: ownerChoice.source,
+        score: ownerChoice.score || null,
+        member: ownerChoice.member ? {
+          slug: ownerChoice.member.slug,
+          role: ownerChoice.member.role,
+          description: ownerChoice.member.description,
+        } : null,
+      },
+      recorded,
+      text: renderPublicPlan(publicPlan),
+    });
+    return;
+  }
+  console.log(renderPublicPlan(publicPlan));
+}
+
+function buildAutomaticPlanTrace(taskDb, task, { actor, actorExplicit = false, owner, goal, summary, firstMove, exit } = {}) {
+  if (!task) return { trace: null, plan: null, ownerChoice: null, ownerForStage: owner || null };
+  const metadata = task.metadata || {};
+  const purpose = cleanPublicText(goal, 240) || taskPurpose(task);
+  const claimedOwner = cleanPublicText(task.claimed_by, 80);
+  const actorNamed = taskTextMentionsActor(actor, `${purpose} ${task.title || ''} ${task.tag || ''}`);
+  const requestedActor = actorExplicit && (!isGenericPlanActor(actor) || actorNamed) ? actor : null;
+  const requestedOwner = owner || claimedOwner || requestedActor || null;
+  const ownerChoice = chooseTaskOwner({
+    purpose,
+    tag: task.tag,
+    requestedOwner,
+    root: taskDb.workspaceRoot(),
+  });
+  const publicPlan = buildPublicPlan({
+    purpose,
+    owner: ownerChoice.owner,
+    ownerReason: ownerChoice.reason,
+    plan: firstMove || summary || metadata.first_move || metadata.stage_summary || '',
+    expected: exit || metadata.exit_condition || '',
+  });
+  return {
+    trace: planTraceData(publicPlan, ownerChoice),
+    plan: publicPlan,
+    ownerChoice: {
+      owner: ownerChoice.owner,
+      source: ownerChoice.source,
+      score: ownerChoice.score || null,
+    },
+    ownerForStage: publicPlan.owner || actor || DEFAULT_OWNER,
+  };
+}
+
+function buildAutomaticResultTrace(taskDb, db, taskId, { actor, proof, changed, checked, passed, failed, cost, saved, tryNext, status, files, commands } = {}) {
+  const task = taskDetail(taskDb, db, taskId);
+  if (!task || taskHasTrace(task, 'TASK_RESULT_TRACE ')) return null;
+  const fields = {
+    actor,
+    changed: cleanPublicText(changed, 320) || 'prepared the work for review',
+    checked: cleanPublicText(checked, 320) || cleanPublicText(proof, 320),
+    passed: cleanPublicText(passed, 240),
+    failed: cleanPublicText(failed, 240),
+    cost: cleanPublicText(cost, 80),
+    saved: cleanPublicText(saved, RESULT_SAVED_TEXT_LIMIT) || 'task trace was updated',
+    tryNext: cleanPublicText(tryNext, 240) || 'review the proof and try the changed work',
+    status: cleanPublicText(status, 160) || 'ready for review',
+    files,
+    commands,
+  };
+  const result = buildPublicResult(task, fields);
+  const savedPaths = appendResultOwnerLog(taskDb.workspaceRoot(), task, result);
+  const trace = resultTraceData(result, { ...fields, savedPaths });
+  return {
+    result,
+    trace,
+    saved_paths: savedPaths,
+  };
+}
+
+function cmdResult(args) {
+  const pos = positional(args);
+  const id = pos[0];
+  if (!id) failTask('atris task result', 'missing_id', 'id required');
+  const fields = {
+    purpose: textFlag(args, ['--purpose', '--goal', '--objective']),
+    changed: textFlag(args, ['--changed', '--result', '--done']),
+    checked: textFlag(args, ['--checked', '--check', '--verified']),
+    passed: textFlag(args, ['--passed', '--pass']),
+    failed: textFlag(args, ['--failed', '--fail']),
+    cost: textFlag(args, ['--cost']),
+    saved: textFlag(args, ['--saved', '--savings']),
+    tryNext: textFlag(args, ['--try', '--try-next', '--handoff']),
+    status: textFlag(args, ['--status']),
+    files: textFlag(args, ['--files']),
+    commands: textFlag(args, ['--commands', '--command']),
+  };
+  if (!fields.changed) failTask('atris task result', 'changed_required', '--changed required');
+  if (!fields.checked) failTask('atris task result', 'checked_required', '--checked required');
+  if (!fields.tryNext) failTask('atris task result', 'try_required', '--try required');
+  const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const taskId = requireTaskId(taskDb, db, id, 'atris task result');
+  const task = taskDetail(taskDb, db, taskId);
+  if (!task) failTask('atris task result', 'not_found', `task not found: ${id}`, 1);
+  const result = buildPublicResult(task, { ...fields, actor });
+  const savedPaths = appendResultOwnerLog(taskDb.workspaceRoot(), task, result);
+  const note = taskDb.noteTask(db, {
+    id: taskId,
+    actor,
+    content: resultTraceNote(result, { ...fields, savedPaths }),
+  });
+  if (!note.noted) failTask('atris task result', note.reason || 'note_failed', `result failed: ${note.reason || 'note_failed'}`, 1);
+  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  const text = renderPublicResult(result);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'result',
+      task_id: taskId,
+      version: note.event.version,
+      projection_path: outPath,
+      result,
+      saved_paths: savedPaths,
+      text,
+      task: compactTaskFromProjection(projection, taskId),
+    });
+    return;
+  }
+  console.log(text);
+}
+
 function taskPageGoal(task) {
   const metadata = task && task.metadata || {};
   const candidates = [
@@ -5383,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') {
@@ -5441,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,
@@ -5462,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,
@@ -5505,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: {
@@ -5558,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;
@@ -5715,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;
@@ -5737,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();
@@ -5764,16 +6650,25 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
   let episode = null;
   let xpProjection = null;
   if (current === 'backlog') {
+    const automaticPlan = buildAutomaticPlanTrace(taskDb, task, {
+      actor,
+      owner: actor,
+      goal,
+      summary,
+      firstMove: String(options.firstMove || ''),
+      exit: String(options.exit || ''),
+    });
     const planned = taskDb.stageTask(db, {
       id: taskId,
       actor,
       stage: 'plan',
       goal,
       summary,
-      owner: actor,
+      owner: automaticPlan.ownerForStage || actor,
       exit: String(options.exit || ''),
       proofNeeded: String(options.proofNeeded || ''),
       firstMove: String(options.firstMove || ''),
+      planTrace: automaticPlan.trace,
     });
     if (!planned.staged) taskStepFailure('atris task step', planned, actionPage);
     stepAction = 'planned';
@@ -5807,7 +6702,15 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
     }
     const lesson = String(options.lesson || '');
     const nextTask = String(options.nextTask || '');
-    const ready = taskDb.readyTask(db, { id: taskId, actor, proof, lesson, nextTask });
+    const resultTrace = buildAutomaticResultTrace(taskDb, db, taskId, { actor, proof });
+    const ready = taskDb.readyTask(db, {
+      id: taskId,
+      actor,
+      proof,
+      lesson,
+      nextTask,
+      resultTrace: resultTrace && resultTrace.trace,
+    });
     if (!ready.ready) taskStepFailure('atris task step', ready, actionPage);
     task = taskDetail(taskDb, db, taskId) || task;
     stepAction = 'ready';
@@ -5822,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';
@@ -5930,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,
@@ -6342,16 +7245,36 @@ 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']),
+    checked: textFlag(args, ['--checked', '--check', '--verified']),
+    passed: textFlag(args, ['--passed', '--pass']),
+    failed: textFlag(args, ['--failed', '--fail']),
+    cost: textFlag(args, ['--cost']),
+    saved: textFlag(args, ['--saved', '--savings']),
+    tryNext: textFlag(args, ['--try', '--try-next', '--handoff']),
+    status: textFlag(args, ['--status']),
+    files: textFlag(args, ['--files']),
+    commands: textFlag(args, ['--commands', '--command']),
+  };
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, id, 'atris task ready');
+  const resultTrace = buildAutomaticResultTrace(taskDb, db, taskId, {
+    actor,
+    proof: String(proof),
+    ...resultFields,
+  });
   const result = taskDb.readyTask(db, {
     id: taskId,
     actor,
     proof: String(proof),
     lesson: typeof lesson === 'string' ? lesson : '',
     nextTask: nextTaskInput.nextTask,
+    resultTrace: resultTrace && resultTrace.trace,
+    landing,
   });
   if (!result.ready) {
     console.error(`ready failed: ${result.reason}`);
@@ -6373,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;
@@ -6397,20 +7320,22 @@ function cmdReady(args) {
       review_pass_count: result.event.payload.review_pass_count,
       agent_certified: agentCertified,
       handoff,
+      result_trace: resultTrace,
       ...(nextTaskInput.ignored ? { review_next_task_ignored: nextTaskInput.ignored } : {}),
       projection_path: outPath,
       task: compactTaskFromProjection(projection, taskId),
     });
     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) {
     console.log(`policy (${hint.id}): ${hint.hint}`);
   }
 }
 
-function cmdAccept(args) {
+async function cmdAccept(args) {
   const pos = positional(args);
   const id = pos[0];
   if (!id) {
@@ -6490,6 +7415,7 @@ function cmdAccept(args) {
   // Inform the gate, never block it: show what the receipts named in the proof
   // actually say so the accepting human isn't trusting prose.
   const evidence = extractReceiptEvidence(proof, projection.workspace_root || process.cwd());
+  const publicSync = hasFlag(args, '--public') ? await publishAcceptAgentXp(args, actor) : null;
   if (wantsJson(args)) {
     printJson({
       ok: true,
@@ -6499,21 +7425,21 @@ function cmdAccept(args) {
       reward: reviewed.episode.reward.value,
       episode: reviewed.episode,
       evidence,
+      public_sync: publicSync,
       xp_projection: xpProjection,
       projection_path: outPath,
       task: compactTaskFromProjection(projection, taskId),
     });
+    if (publicSync && !publicSync.ok) process.exitCode = 1;
     return;
   }
-  console.log(`accepted ${taskRef(compactTaskFromProjection(projection, taskId))} reward=${reviewed.episode.reward.value}`);
-  if (evidence) {
-    evidence.receipts.forEach((receipt) => {
-      const verdict = receipt.verifier_passed === true ? ' verifier:passed'
-        : receipt.verifier_passed === false ? ' verifier:FAILED' : '';
-      console.log(`  receipt: ${receipt.path}${verdict}`);
-    });
-    evidence.missing.forEach((missingPath) => console.log(`  receipt: ${missingPath} MISSING`));
-  }
+  console.log(renderAcceptLanding({
+    task: taskDetail(taskDb, db, taskId) || compactTaskFromProjection(projection, taskId),
+    proof,
+    nextTask,
+    publicSync,
+  }));
+  if (publicSync && !publicSync.ok) process.exitCode = 1;
 }
 
 function stampAutoAcceptMetadata(taskDb, db, taskId, actor, policy) {
@@ -6693,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),
     });
@@ -7620,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>',
@@ -7632,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.';
@@ -7975,22 +8913,39 @@ async function handleTaskApi(req, res, taskDb, db) {
     });
   }
   if (op === 'plan') {
+    const actor = String(body.actor || DEFAULT_OWNER);
+    const goal = String(body.goal || body.objective || '');
+    const summary = String(body.summary || body.plan || '');
+    const owner = String(body.owner || body.assignee || '');
+    const exit = String(body.exit || body.exit_condition || '');
+    const firstMove = String(body.first_move || body.firstMove || body.first || '');
+    const task = taskDetail(taskDb, db, taskId);
+    const automaticPlan = buildAutomaticPlanTrace(taskDb, task, {
+      actor,
+      actorExplicit: Boolean(body.actor),
+      owner,
+      goal,
+      summary,
+      firstMove,
+      exit,
+    });
     const result = taskDb.stageTask(db, {
       id: taskId,
-      actor: String(body.actor || DEFAULT_OWNER),
+      actor,
       stage: 'plan',
-      goal: String(body.goal || body.objective || ''),
-      summary: String(body.summary || body.plan || ''),
-      owner: String(body.owner || body.assignee || ''),
-      exit: String(body.exit || body.exit_condition || ''),
+      goal,
+      summary,
+      owner: automaticPlan.ownerForStage || owner,
+      exit,
       proofNeeded: String(body.proof_needed || body.proofNeeded || body.proof || body.verify || ''),
-      firstMove: String(body.first_move || body.firstMove || body.first || ''),
+      firstMove,
       nextButton: String(body.next_button || body.nextButton || ''),
       confidence: body.confidence,
+      planTrace: automaticPlan.trace,
     });
     if (!result.staged) return sendJson(res, 409, { ok: false, reason: result.reason, detail: stageErrorDetail('task plan', result.reason, result) });
     const { projection, outPath } = writeDefaultProjection(taskDb, db);
-    return sendJson(res, 200, { ok: true, action: 'planned', task_id: taskId, version: result.event.version, stage_packet: result.stage_packet, projection_path: outPath, task: taskFromProjection(projection, taskId) });
+    return sendJson(res, 200, { ok: true, action: 'planned', task_id: taskId, version: result.event.version, plan_trace: automaticPlan.trace, stage_packet: result.stage_packet, projection_path: outPath, task: taskFromProjection(projection, taskId) });
   }
   if (op === 'do') {
     const firstMove = String(body.first_move || body.firstMove || body.first || '').trim();
@@ -8097,12 +9052,34 @@ async function handleTaskApi(req, res, taskDb, db) {
     const proofIssue = meaningfulTaskProofIssue(proof);
     if (proofIssue) return sendProofIssue(res, proof, proofIssue);
     const nextTaskInput = normalizeReviewNextTaskInput(body.next);
+    const actor = String(body.actor || DEFAULT_OWNER);
+    const resultTrace = buildAutomaticResultTrace(taskDb, db, taskId, {
+      actor,
+      proof,
+      changed: body.changed || body.result || body.done,
+      checked: body.checked || body.check || body.verified,
+      passed: body.passed || body.pass,
+      failed: body.failed || body.fail,
+      cost: body.cost,
+      saved: body.saved || body.savings,
+      tryNext: body.try_next || body.tryNext || body.try || body.handoff,
+      status: body.status,
+      files: body.files,
+      commands: body.commands || body.command,
+    });
     const result = taskDb.readyTask(db, {
       id: taskId,
-      actor: String(body.actor || DEFAULT_OWNER),
+      actor,
       proof,
       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);
@@ -8110,6 +9087,7 @@ async function handleTaskApi(req, res, taskDb, db) {
       ok: true,
       action: 'ready',
       task_id: taskId,
+      result_trace: resultTrace,
       ...(nextTaskInput.ignored ? { review_next_task_ignored: nextTaskInput.ignored } : {}),
       projection_path: outPath,
       task: taskFromProjection(projection, taskId),
@@ -8300,6 +9278,10 @@ async function run(args) {
     case 'continue':
       return cmdContinueWork(rest);
     case 'chat':   return cmdChat(rest);
+    case 'plan-preview':
+    case 'preview-plan':
+    case 'plan-card':
+      return cmdPlanPreview(rest);
     case 'note':   return cmdNote(rest);
     case 'say':    return cmdNote(rest);
     case 'show':   return cmdShow(rest);
@@ -8309,6 +9291,7 @@ async function run(args) {
     case 'chat-review':
       return cmdReviewChat(rest);
     case 'ready':  return cmdReady(rest);
+    case 'result': return cmdResult(rest);
     case 'accept': return cmdAccept(rest);
     case 'auto-accept-certified':
     case 'auto-accept':