atris 3.53.0 → 3.56.0

package/commands/task.js

@@ -9,7 +9,17 @@ const { execSync } = require('node:child_process');
 const path = require('path');
 const os = require('os');
 const { hasFlag } = require('../lib/arg-parser');
-const { taskProofState } = require('../lib/task-proof');
+const { argsWantHelp } = require('../lib/noninteractive');
+const {
+  compactErrorPayload,
+  compactSuccessPayload,
+  printCliJson,
+} = require('../lib/cli-json');
+const {
+  taskProofState,
+  LOCAL_SUCCESS_PROOF_EXAMPLE,
+  unrunNamedProofCommandIssue,
+} = require('../lib/task-proof');
 const {
   candidatePolicyGate,
   evaluateAutoAccept,
@@ -50,6 +60,7 @@ const {
   decisionMarkerFor,
   DECISION_REFUSE_REASON,
 } = require('../lib/task-decision');
+const { buildFirstMinute, deskNextCommand, personName, pickNext, speakFirstMinute, taskCommand, taskNextCommand } = require('../lib/first-minute');
 
 const DEFAULT_OWNER = process.env.ATRIS_AGENT_ID
   || process.env.USER
@@ -151,11 +162,12 @@ atris task - durable local task state (SQLite, gitignored)
     atris task ready <id> --verify
     atris autoland tick   # second check runs, task lands
 
-  atris task                              Show the task desk
+  atris task                              Same two-line next as bare atris
+  atris task desk [--all]                 Show the full task desk
   atris task new "<title>" [--what-changes "..."] [--why-it-matters "..."] [--done-looks-like "..."] [--verify <cmd>]
                                            Create a task with a plain explanation; omitted fields get honest defaults
   atris task next [--tag <tag>] [--create-next]
-                                           Claim/show next open task; optionally create the generated Endgame fallback
+                                           Same next command as bare atris and the task desk; --create-next still seeds Endgame fallback
   atris task continue-work <id>           Create/reuse a certified Review follow-up task
   atris task say <id> "<message>"         Add context to a task
   atris task chat <id> "<message>" [--goal "..."]  Refine a task chat + working goal
@@ -163,7 +175,8 @@ atris task - durable local task state (SQLite, gitignored)
                                            Agent proof ready; native goal can complete
   atris task ready <id> --verify "<cmd>" --result "<sentence>"
                                            Run <cmd>; only ready if it exits 0 (executed proof)
-                                           Writes atris/runs/ receipt (pass or fail), folds path into proof
+                                           Writes atris/runs/ receipt (pass or fail); that local pass is enough proof
+                                           Optional CI URL only with --proof-url and --i-fetched
   atris task receipt <id> --verify "<cmd>" Run <cmd> and write an atris/runs/ receipt without going to ready
   atris task plan-preview "<purpose>" [--tag <tag>] [--owner <member>] [--task <id>]
                                            Show the plain Plan before work starts
@@ -440,12 +453,18 @@ function jsonModeActive() {
 
 function failTask(label, reason, detail, exitCode = 2) {
   if (jsonModeActive()) {
-    console.log(JSON.stringify({
-      ok: false,
-      command: label,
-      reason,
-      detail: detail || null,
-    }));
+    printCliJson(
+      {
+        ok: false,
+        command: label,
+        reason,
+        detail: detail || null,
+        selected_ref: null,
+        next_command: null,
+      },
+      compactErrorPayload({ reason, detail: detail || null }),
+      process.argv.slice(2),
+    );
   } else {
     console.error(detail || `${label}: ${reason}`);
   }
@@ -472,8 +491,8 @@ function proofFlagValue(args) {
   return typeof proof === 'string' ? proof.trim() : '';
 }
 
-function resultSentenceIssue(value) {
-  const check = explainResult(value);
+function resultSentenceIssue(value, { allowCommandMention = false } = {}) {
+  const check = explainResult(value, { allowCommandMention });
   return check.ok ? null : check.reason;
 }
 
@@ -481,13 +500,35 @@ function readyResultDetail(reason) {
   return reason ? `${READY_RESULT_TEACHING}\n${reason}` : READY_RESULT_TEACHING;
 }
 
-function requireResultSentence(label, value, { ready = false } = {}) {
-  const issue = resultSentenceIssue(value);
+function requireResultSentence(label, value, { ready = false, allowCommandMention = false } = {}) {
+  const issue = resultSentenceIssue(value, { allowCommandMention });
   if (!issue) return String(value || '').replace(/\s+/g, ' ').trim();
   const detail = ready ? readyResultDetail(issue) : issue;
   failTask(label, 'weak_result', detail);
 }
 
+function weakProofDetail(issue) {
+  return `meaningful proof required: ${issue}\n${LOCAL_SUCCESS_PROOF_EXAMPLE}`;
+}
+
+function requireMeaningfulTaskProof(label, proof, { required = true } = {}) {
+  const issue = meaningfulTaskProofIssue(proof, { required });
+  if (issue) failTask(label, 'weak_proof', weakProofDetail(issue));
+}
+
+function requireRanNamedProofCommand(label, proof, ranCommand = '') {
+  const issue = unrunNamedProofCommandIssue(proof, ranCommand);
+  if (issue) failTask(label, issue.reason, issue.detail);
+}
+
+function sendProofIssue(res, proof, issue) {
+  return sendJson(res, 400, {
+    ok: false,
+    reason: String(proof || '').trim() ? 'weak_proof' : 'proof_required',
+    detail: weakProofDetail(issue),
+  });
+}
+
 function textFlag(args, names) {
   for (const name of names) {
     const value = flag(args, name);
@@ -658,19 +699,6 @@ function missionXpProofBoundaryEvaluation(task, proofOverride = null) {
   };
 }
 
-function requireMeaningfulTaskProof(label, proof, { required = true } = {}) {
-  const issue = meaningfulTaskProofIssue(proof, { required });
-  if (issue) failTask(label, 'weak_proof', `meaningful proof required: ${issue}`);
-}
-
-function sendProofIssue(res, proof, issue) {
-  return sendJson(res, 400, {
-    ok: false,
-    reason: String(proof || '').trim() ? 'weak_proof' : 'proof_required',
-    detail: `meaningful proof required: ${issue}`,
-  });
-}
-
 function positional(args) {
   return args.filter((a, i) => {
     if (a.startsWith('--')) return false;
@@ -6134,10 +6162,27 @@ function renderTaskDesk(rows, refRows = rows) {
   if (active.length === 0) console.log('clear   no active tasks');
   console.log('');
   console.log(`active ${active.length} / done ${done.length}`);
-  console.log('next: atris task next');
+  console.log(`next: ${deskNextCommand(displayRows, personName())}`);
 }
 
 function cmdAdd(args) {
+  const root = process.cwd();
+  // Empty folder talks like bare atris. A leftover title is not a
+  // task desk. After init, a title still files.
+  if (isUninitializedTaskFolder(root)) {
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'init',
+        command: 'atris init --minimal',
+        task_id: null,
+        projection_path: null,
+        task: null,
+      });
+      return;
+    }
+    return speakFirstMinute({ root, fresh: true });
+  }
   const pos = positional(args);
   const title = pos.join(' ').trim();
   if (!title) {
@@ -6446,6 +6491,15 @@ function cmdDay(args) {
   console.log('add: atris task delegate "..." --to task-planner --tag tasks');
 }
 
+function cmdFirstMinute() {
+  const root = process.cwd();
+  const screen = buildFirstMinute({
+    root,
+    fresh: !fs.existsSync(path.join(root, 'atris')),
+  });
+  console.log(screen.text);
+}
+
 function cmdHome(args) {
   const all = hasFlag(args, '--all');
   const everywhere = taskScopeEverywhere(args);
@@ -6771,7 +6825,108 @@ function createEndgameSeedTask(taskDb, db, seed, owner) {
   };
 }
 
+function nextActionFromCommand(command) {
+  const match = String(command || '').trim().match(/^atris (?:task|mission) (\S+)/);
+  const verb = match ? match[1] : '';
+  if (!verb || verb === 'new') return 'none';
+  return verb;
+}
+
+function cmdNextTruth(args) {
+  const owner = flag(args, '--as') || personName() || DEFAULT_OWNER;
+  const scope = taskQueueScopeFromArgs(args);
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot();
+  const rows = taskDb.listTasks(db, { workspaceRoot, limit: 500 });
+  const existingProj = readProjectionFile(workspaceRoot);
+  let projection;
+  let outPath;
+  if (rows.length === 0 && existingProj && Array.isArray(existingProj.tasks) && existingProj.tasks.length > 0) {
+    projection = existingProj;
+    outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
+  } else {
+    const written = writeDefaultProjection(taskDb, db);
+    projection = written.projection;
+    outPath = written.outPath;
+  }
+  const scoped = filterTasksByScope(projection.tasks || [], scope);
+  const openDecisions = scoped.filter((task) => task && isDecisionTask(task) && task.status === 'open');
+  const actionable = scoped.filter((task) => task && !isDecisionTask(task));
+  const picked = pickNext({ tasks: actionable, person: owner });
+  const command = picked.task ? (picked.command || taskCommand(picked.task, owner)) : taskNextCommand(actionable, owner);
+  const task = picked.task || null;
+
+  if (!task && openDecisions.length) {
+    if (wantsJson(args)) {
+      printJson({
+        ok: false,
+        action: 'refused',
+        reason: DECISION_REFUSE_REASON,
+        skipped_decision_count: openDecisions.length,
+        owner: String(owner),
+        scope: normalizeTaskQueueScope(scope),
+        projection_path: outPath,
+      });
+      process.exit(1);
+    }
+    console.error(DECISION_REFUSE_REASON);
+    process.exit(1);
+  }
+
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: nextActionFromCommand(command),
+      command,
+      task_id: task ? task.id : null,
+      owner: String(owner),
+      scope: normalizeTaskQueueScope(scope),
+      projection_path: outPath,
+      task: task ? compactTaskFromProjection(projection, task.id) : null,
+    });
+    return;
+  }
+
+  if (!task) {
+    console.log(noOpenTasksMessage(scope));
+    console.log(`next: ${command}`);
+    return;
+  }
+  console.log(`next: ${command}`);
+}
+
+function isUninitializedTaskFolder(cwd = process.cwd()) {
+  const workspace = getTaskDb().workspaceRoot(cwd);
+  if (fs.existsSync(path.join(workspace, 'atris'))) return false;
+  const existing = readProjectionFile(workspace);
+  return !(existing && Array.isArray(existing.tasks) && existing.tasks.length > 0);
+}
+
 function cmdNext(args) {
+  const root = process.cwd();
+  // Empty folder talks like bare atris. Walk up like the task db so a
+  // project subdir stays in the room; stop before inheriting /tmp.
+  // A leftover projection with live tasks still names that work.
+  if (isUninitializedTaskFolder(root)) {
+    if (wantsJson(args)) {
+      printJson({
+        ok: true,
+        action: 'init',
+        command: 'atris init --minimal',
+        task_id: null,
+        owner: String(flag(args, '--as') || personName() || DEFAULT_OWNER),
+        scope: normalizeTaskQueueScope(taskQueueScopeFromArgs(args)),
+        projection_path: null,
+        task: null,
+      });
+      return;
+    }
+    const screen = buildFirstMinute({ root, fresh: true });
+    console.log(screen.text);
+    return;
+  }
+  if (!hasFlag(args, '--create-next')) return cmdNextTruth(args);
   const owner = flag(args, '--as') || DEFAULT_OWNER;
   const scope = taskQueueScopeFromArgs(args);
   const scoped = !taskQueueScopeIsEmpty(scope);
@@ -8637,7 +8792,7 @@ function taskStepError(reason, detail, { status = 409, exitCode = 1, page = null
 }
 
 function taskStepStatusForReason(reason) {
-  if (['goal_required', 'exit_required', 'proof_needed_required', 'first_move_required', 'proof_required', 'weak_proof', 'invalid_reward'].includes(reason)) {
+  if (['goal_required', 'exit_required', 'proof_needed_required', 'first_move_required', 'proof_required', 'weak_proof', 'proof_command_not_run', 'invalid_reward'].includes(reason)) {
     return 400;
   }
   if (reason === 'not_found') return 404;
@@ -8848,7 +9003,11 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
     const proof = String(options.proof || '').trim();
     const proofIssue = meaningfulTaskProofIssue(proof);
     if (proofIssue) {
-      throw taskStepError(proof ? 'weak_proof' : 'proof_required', `meaningful proof required: ${proofIssue}`, { status: 400, exitCode: 2, page: actionPage });
+      throw taskStepError(proof ? 'weak_proof' : 'proof_required', weakProofDetail(proofIssue), { status: 400, exitCode: 2, page: actionPage });
+    }
+    const unrunIssue = unrunNamedProofCommandIssue(proof, '');
+    if (unrunIssue) {
+      throw taskStepError(unrunIssue.reason, unrunIssue.detail, { status: 400, exitCode: 2, page: actionPage });
     }
     const missionXpIssue = missionXpEndToEndProofIssue(task, proof, task.workspace_root || process.cwd());
     if (missionXpIssue) {
@@ -8895,7 +9054,11 @@ function runTaskStep(taskDb, db, taskId, options = {}) {
     const proof = String(options.proof || '').trim();
     const proofIssue = meaningfulTaskProofIssue(proof);
     if (proofIssue) {
-      throw taskStepError(proof ? 'weak_proof' : 'proof_required', `meaningful proof required: ${proofIssue}`, { status: 400, exitCode: 2, page: actionPage });
+      throw taskStepError(proof ? 'weak_proof' : 'proof_required', weakProofDetail(proofIssue), { status: 400, exitCode: 2, page: actionPage });
+    }
+    const unrunIssue = unrunNamedProofCommandIssue(proof, '');
+    if (unrunIssue) {
+      throw taskStepError(unrunIssue.reason, unrunIssue.detail, { status: 400, exitCode: 2, page: actionPage });
     }
     const parsedReward = parseStepReviewReward(options.reward);
     if (!parsedReward.ok) {
@@ -9127,24 +9290,51 @@ function cmdCurrentStep(args) {
   } catch (error) {
     const errorCurrent = error.current || null;
     if (wantsJson(args)) {
-      printJson({
-        ok: false,
-        action: 'current_step',
-        reason: error.reason || 'step_failed',
-        detail: error.message,
-        selected_task_id: errorCurrent ? errorCurrent.selected_task_id : null,
-        selected_ref: errorCurrent ? errorCurrent.selected_ref : null,
-        selected_next_key: selectedNextKeyFromCurrent(errorCurrent),
-        current: errorCurrent,
-        page: error.page || null,
-      });
+      const selectedRef = errorCurrent ? errorCurrent.selected_ref : null;
+      const nextCommand = error.page?.stage?.next_action?.command
+        || (errorCurrent && errorCurrent.next && errorCurrent.next.command)
+        || null;
+      printCliJson(
+        {
+          ok: false,
+          action: 'current_step',
+          reason: error.reason || 'step_failed',
+          detail: error.message,
+          selected_task_id: errorCurrent ? errorCurrent.selected_task_id : null,
+          selected_ref: selectedRef,
+          selected_next_key: selectedNextKeyFromCurrent(errorCurrent),
+          next_command: nextCommand,
+          current: errorCurrent,
+          page: error.page || null,
+        },
+        compactErrorPayload({
+          reason: error.reason || 'step_failed',
+          detail: error.message,
+          selected_ref: selectedRef,
+          next_command: nextCommand,
+        }),
+        args,
+      );
     } else {
       console.error(error.message || 'atris task current-step failed');
     }
     process.exit(error.exitCode || 1);
   }
   if (wantsJson(args)) {
-    printJson(result);
+    const nextCommand = result.page?.stage?.next_action?.command || null;
+    printCliJson(
+      result,
+      compactSuccessPayload({
+        action: 'current_step',
+        ids: {
+          selected_task_id: result.selected_task_id || null,
+          selected_ref: result.selected_ref || null,
+          step_action: result.step && result.step.step_action ? result.step.step_action : null,
+        },
+        next_command: nextCommand,
+      }),
+      args,
+    );
     return;
   }
   console.log(`current-step ${taskRef(result.task)} -> ${result.step.step_action}`);
@@ -9610,14 +9800,38 @@ function cmdReady(args) {
     console.error('atris task ready: id required');
     process.exit(2);
   }
-  // Two ways to prove: --proof "<note>" (claimed, pattern-checked, unchanged) or
-  // --verify "<command>" which actually RUNS the command and gates ready on exit 0,
-  // turning a claim into executed evidence. --verify can carry an optional --proof note.
+  // Two ways to prove: --proof "<note>" (claimed, pattern-checked) or
+  // --verify "<command>" which actually RUNS the command and gates ready on exit 0.
+  // If --proof names npm test, node --test, or git diff --check, this process
+  // must have run that command. A sentence that names one of those is a lie.
   const proofFlag = flag(args, '--proof');
   const verifyFlag = flag(args, '--verify');
-  const resultSentence = requireResultSentence('atris task ready', textFlag(args, ['--result']), { ready: true });
+  const proofUrl = textFlag(args, ['--proof-url']);
+  const iFetched = hasFlag(args, '--i-fetched');
+  if (proofUrl && !iFetched) {
+    failTask(
+      'atris task ready',
+      'unfetched_proof_url',
+      'CI run URLs only count after atris fetches them, or with --proof-url and --i-fetched',
+    );
+  }
+  if (iFetched && !proofUrl && !(typeof proofFlag === 'string' && /https?:\/\/github[.]com\//i.test(proofFlag))) {
+    failTask(
+      'atris task ready',
+      'proof_url_required',
+      '--i-fetched requires --proof-url <actions-run-url> (or a URL inside --proof)',
+    );
+  }
   const usedVerify = typeof verifyFlag === 'string' ? verifyFlag.trim() : '';
+  const resultSentence = requireResultSentence('atris task ready', textFlag(args, ['--result']), {
+    ready: true,
+    allowCommandMention: Boolean(usedVerify),
+  });
   let proof = typeof proofFlag === 'string' ? proofFlag : '';
+  if (proofUrl && iFetched) {
+    const attested = `[i-fetched] ${proofUrl}`;
+    proof = proof.trim() ? `${proof.trim()} ${attested}` : attested;
+  }
   const verifyAutoCertifyAllowed = !usedVerify || isAutoCertifyVerifyCommandAllowed(verifyFlag);
   if (usedVerify) {
     // Run the verifier once and write a receipt (pass or fail) so the review
@@ -9638,6 +9852,15 @@ function cmdReady(args) {
     // this codebase fails there, and one that passes anywhere passes there too.
     if (!hasFlag(args, '--no-falsify-check')) {
       const { probeVerifierCanFail } = require('../lib/falsifier-probe');
+      const { classifyVerifier } = require('../lib/verifier-quality');
+      const quality = classifyVerifier(verifyFlag);
+      if (!quality.ok) {
+        console.error(`atris task ready: weak verifier — ${quality.reason}`);
+        console.error(`  command: ${verifyFlag}`);
+        console.error('  allowlisted examples: node --test, npm test, git diff --check, node --check, rg <symbol>');
+        console.error('  or pass --no-falsify-check to accept anyway.');
+        process.exit(1);
+      }
       const probe = probeVerifierCanFail({ command: verifyFlag });
       if (probe.probed && probe.canFail === false) {
         console.error(`atris task ready: this check cannot fail — ${probe.reason}`);
@@ -9656,6 +9879,7 @@ function cmdReady(args) {
     process.exit(2);
   }
   requireMeaningfulTaskProof('atris task ready', proof);
+  requireRanNamedProofCommand('atris task ready', proof, usedVerify);
   const lesson = flag(args, '--lesson') || '';
   const nextTaskInput = normalizeReviewNextTaskInput(typeof flag(args, '--next') === 'string' ? flag(args, '--next') : '');
   const landing = landingFlags(args);
@@ -9760,7 +9984,12 @@ function cmdReady(args) {
   if (policyHints.length) handoff.policy_hints = policyHints;
   if (readyPolicyGate.gate.advisories.length) handoff.policy_gate = readyPolicyGate.gate;
   if (wantsJson(args)) {
-    printJson({
+    const taskCard = compactTaskFromProjection(projection, taskId);
+    const nextCommand = handoff.review_chat_command
+      || (agentCertified
+        ? `atris task accept ${taskRef(taskCard || result.row || taskId)}`
+        : `atris task reviews`);
+    const fullReady = {
       ok: true,
       action: 'ready',
       task_id: taskId,
@@ -9773,8 +10002,23 @@ function cmdReady(args) {
       landing_advisory: landingAdvisory,
       ...(nextTaskInput.ignored ? { review_next_task_ignored: nextTaskInput.ignored } : {}),
       projection_path: outPath,
-      task: compactTaskFromProjection(projection, taskId),
-    });
+      task: taskCard,
+      next_command: nextCommand,
+    };
+    printCliJson(
+      fullReady,
+      compactSuccessPayload({
+        action: 'ready',
+        ids: {
+          task_id: taskId,
+          selected_ref: taskRef(taskCard || result.row || taskId),
+          version: result.event.version,
+          agent_certified: agentCertified,
+        },
+        next_command: nextCommand,
+      }),
+      args,
+    );
     return;
   }
   console.log(`ready for approval ${taskRef(compactTaskFromProjection(projection, taskId))} v${result.event.version}`);
@@ -11043,15 +11287,23 @@ function importTodoFile(taskDb, db, target) {
   const parsed = parseTodoFile(filePath);
   const ws = taskDb.workspaceRoot();
   const all = [
-    ...parsed.backlog.map(t => ({ ...t, importStatus: 'open' })),
-    ...parsed.inProgress.map(t => ({ ...t, importStatus: 'claimed' })),
-    ...(parsed.review || []).map(t => ({ ...t, importStatus: 'review' })),
+    ...parsed.backlog.map(t => ({ ...t, importStatus: 'open', sourceFile: filePath })),
+    ...parsed.inProgress.map(t => ({ ...t, importStatus: 'claimed', sourceFile: filePath })),
+    ...(parsed.review || []).map(t => ({ ...t, importStatus: 'review', sourceFile: filePath })),
   ];
+  const knownTitles = new Set(
+    taskDb.listTasks(db, { workspaceRoot: ws, limit: 500 }).map((row) => taskDb.normalizeTitle(row.title))
+  );
   let inserted = 0;
   let skipped = 0;
   for (const t of all) {
     if (!t.title) continue;
-    const sk = taskDb.sourceKey(filePath, t.title);
+    const normalized = taskDb.normalizeTitle(t.title);
+    if (knownTitles.has(normalized)) {
+      skipped++;
+      continue;
+    }
+    const sk = taskDb.sourceKey(t.sourceFile || filePath, t.title);
     const result = taskDb.addTask(db, {
       title: t.title,
       tag: t.tag || null,
@@ -11061,11 +11313,72 @@ function importTodoFile(taskDb, db, target) {
       claimedBy: t.claimed || null,
       metadata: { todo_id: t.id, todo_tags: t.tags || [], claimed: t.claimed, stage: t.stage, verify: t.verify },
     });
-    if (result.inserted) inserted++; else skipped++;
+    if (result.inserted) {
+      inserted++;
+      knownTitles.add(normalized);
+    } else {
+      skipped++;
+    }
+  }
+  return { ok: true, inserted, skipped, filePath, knownTitles };
+}
+
+function importJournalFile(taskDb, db, journalPath, knownTitles = null) {
+  const filePath = path.resolve(journalPath);
+  if (!fs.existsSync(filePath)) {
+    return { ok: false, reason: 'not_found', filePath, inserted: 0, skipped: 0 };
+  }
+  const { parseSection } = require('../lib/todo-fallback');
+  const { parseInboxItems } = require('../lib/file-ops');
+  const content = fs.readFileSync(filePath, 'utf8');
+  const ws = taskDb.workspaceRoot();
+  const titles = knownTitles || new Set(
+    taskDb.listTasks(db, { workspaceRoot: ws, limit: 500 }).map((row) => taskDb.normalizeTitle(row.title))
+  );
+  const all = [
+    ...parseSection(content, 'Backlog').map((t) => ({ ...t, importStatus: 'open' })),
+    ...parseSection(content, 'In Progress').map((t) => ({ ...t, importStatus: 'claimed' })),
+    ...parseInboxItems(content).map((item) => ({
+      id: `I${item.id}`,
+      title: item.text,
+      tag: 'inbox',
+      importStatus: 'open',
+    })),
+  ];
+  let inserted = 0;
+  let skipped = 0;
+  for (const t of all) {
+    if (!t.title) continue;
+    const normalized = taskDb.normalizeTitle(t.title);
+    if (titles.has(normalized)) {
+      skipped++;
+      continue;
+    }
+    const sk = taskDb.sourceKey(filePath, t.title);
+    const result = taskDb.addTask(db, {
+      title: t.title,
+      tag: t.tag || null,
+      workspaceRoot: ws,
+      sourceKey: sk,
+      status: t.importStatus,
+      claimedBy: t.claimed || null,
+      metadata: { todo_id: t.id, source: 'journal_import' },
+    });
+    if (result.inserted) {
+      inserted++;
+      titles.add(normalized);
+    } else {
+      skipped++;
+    }
   }
   return { ok: true, inserted, skipped, filePath };
 }
 
+function todayJournalPath() {
+  const { getLogPath } = require('../lib/file-ops');
+  return getLogPath().logFile;
+}
+
 function cmdImport(args) {
   const pos = positional(args);
   const target = pos[0] || 'atris/TODO.md';
@@ -11076,7 +11389,9 @@ function cmdImport(args) {
     console.error(`atris task import: file not found: ${result.filePath}`);
     process.exit(2);
   }
-  const { inserted, skipped, filePath } = result;
+  const journalResult = importJournalFile(taskDb, db, todayJournalPath(), result.knownTitles);
+  const inserted = result.inserted + (journalResult.ok ? journalResult.inserted : 0);
+  const skipped = result.skipped + (journalResult.ok ? journalResult.skipped : 0);
   const { outPath } = writeDefaultProjection(taskDb, db);
   if (wantsJson(args)) {
     printJson({
@@ -11084,12 +11399,16 @@ function cmdImport(args) {
       action: 'imported',
       inserted,
       skipped,
-      source: filePath,
+      source: result.filePath,
+      journal: journalResult.ok ? journalResult.filePath : null,
       projection_path: outPath,
     });
     return;
   }
-  console.log(`imported ${inserted} new, skipped ${skipped} (already imported), source=${filePath}`);
+  console.log(`imported ${inserted} new, skipped ${skipped} (already imported), source=${result.filePath}`);
+  if (journalResult.ok && journalResult.inserted > 0) {
+    console.log(`journal imported ${journalResult.inserted} from ${journalResult.filePath}`);
+  }
 }
 
 function cmdWhere(args) {
@@ -11275,12 +11594,22 @@ function cmdSetup(args) {
   const db = taskDb.open();
   const ws = taskDb.workspaceRoot();
   let importResult = null;
+  let journalResult = null;
   if (hasFlag(args, '--import-todo')) {
     importResult = importTodoFile(taskDb, db, flag(args, '--todo') || 'atris/TODO.md');
     if (!importResult.ok && flag(args, '--todo')) {
       console.error(`atris task setup: TODO file not found: ${importResult.filePath}`);
       process.exit(2);
     }
+    if (importResult.ok) {
+      journalResult = importJournalFile(taskDb, db, todayJournalPath(), importResult.knownTitles);
+      importResult = {
+        ...importResult,
+        inserted: importResult.inserted + (journalResult.ok ? journalResult.inserted : 0),
+        skipped: importResult.skipped + (journalResult.ok ? journalResult.skipped : 0),
+        journal: journalResult.ok ? journalResult.filePath : null,
+      };
+    }
   }
   const { projection, outPath } = writeDefaultProjection(taskDb, db);
   if (wantsJson(args)) {
@@ -11293,6 +11622,7 @@ function cmdSetup(args) {
         inserted: importResult.inserted,
         skipped: importResult.skipped,
         source: importResult.filePath,
+        journal: importResult.journal || null,
       } : null,
       projection,
     });
@@ -12572,6 +12902,14 @@ function postTaskApiReady({ res, taskDb, db, taskId, body }) {
   const proof = String(body.proof || '').trim();
   const proofIssue = meaningfulTaskProofIssue(proof);
   if (proofIssue) return sendProofIssue(res, proof, proofIssue);
+  const unrunIssue = unrunNamedProofCommandIssue(proof, '');
+  if (unrunIssue) {
+    return sendJson(res, 400, {
+      ok: false,
+      reason: unrunIssue.reason,
+      detail: unrunIssue.detail,
+    });
+  }
   const nextTaskInput = normalizeReviewNextTaskInput(body.next);
   const actor = String(body.actor || DEFAULT_OWNER);
   const resultText = String(body.result || '').replace(/\s+/g, ' ').trim();
@@ -12817,8 +13155,9 @@ async function runTaskCommand(args) {
   const raw = args || [];
   if (raw.includes('--help') || raw.includes('-h')) return help();
   const first = raw[0];
-  const sub = !first || first.startsWith('--') ? 'desk' : first;
-  const rest = !first || first.startsWith('--') ? raw : raw.slice(1);
+  if (!first) return cmdFirstMinute();
+  const sub = first.startsWith('--') ? 'desk' : first;
+  const rest = first.startsWith('--') ? raw : raw.slice(1);
   switch (sub) {
     case 'desk':   return cmdHome(rest);
     case 'today':  return cmdDay(rest);
@@ -12971,6 +13310,42 @@ const MUTATING_TASK_COMMANDS = new Set([
 async function run(args) {
   const raw = args || [];
   const sub = !raw[0] || raw[0].startsWith('--') ? 'desk' : raw[0];
+  // `task accept --help` is a help request, not a run. Accept mutates
+  // review rows, so never list or accept just to show usage.
+  if (sub === 'accept' && argsWantHelp(raw.slice(1))) {
+    console.log('Usage: atris task accept <id> [--proof "..."] [--public]');
+    return;
+  }
+  // `task claim --help` is a help request, not a run. Claim mutates
+  // ownership, so never list or claim just to show usage.
+  if (sub === 'claim' && argsWantHelp(raw.slice(1))) {
+    console.log('Usage: atris task claim <id> --as <member>');
+    return;
+  }
+  // `task ready --help` is a help request, not a run. Ready mutates
+  // review state, so never list or ready just to show usage.
+  if (sub === 'ready' && argsWantHelp(raw.slice(1))) {
+    console.log('Usage: atris task ready <id> --proof "..." --result "<sentence>"');
+    return;
+  }
+  // `task step --help` is a help request, not a run. Step mutates
+  // Plan/Do/Review, so never list or step just to show usage.
+  if (sub === 'step' && argsWantHelp(raw.slice(1))) {
+    console.log('Usage: atris task step <id> [--json]');
+    return;
+  }
+  // `task next --help` is a help request, not a run. Next can open
+  // the task db or print the desk, so never list or claim just to show usage.
+  if (sub === 'next' && argsWantHelp(raw.slice(1))) {
+    console.log('Usage: atris task next [--tag <tag>] [--create-next]');
+    return;
+  }
+  // `task show --help` is a help request, not a run. Show can dump
+  // a task card or the encyclopedia, so never list or show just to show usage.
+  if (sub === 'show' && argsWantHelp(raw.slice(1))) {
+    console.log('Usage: atris task show <id> [--json]');
+    return;
+  }
   const result = await runTaskCommand(raw);
   const skipsRender = sub === 'clear-done' && hasFlag(raw, '--dry-run');
   if (MUTATING_TASK_COMMANDS.has(sub) && !skipsRender) autoRenderTodoFromDb();