atris 3.43.0 → 3.44.0

package/atris/skills/design/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: design
 description: Frontend aesthetics policy. Use when building UI, components, landing pages, dashboards, or any frontend work. Prevents generic ai-generated look.
-version: 3.0.0
+version: 3.1.0
 allowed-tools: Read, Write, Edit, Bash, Glob
 tags:
   - design
@@ -108,6 +108,12 @@ Every entry: id, rule, detector, status. A detector is a regex/command a gate ca
 | D7 | no em dashes in UI copy or prose | U+2014 scan | graduated (atris slop) |
 | D8 | no claude-beige backgrounds, no instrument serif as default | judgment | active |
 | D9 | fuzzy wish gets translated to craft vocabulary and echoed back before building | judgment | active |
+| D10 | measured tokens over vibes: new components start from a measured recipe (exact colors, spacing, radii, type from a proven source), never from scratch | judgment | active |
+| D11 | layout contracts, not dioramas: min-height over fixed height, fluid max-width over fixed px, every overflow reachable (scroll or +N more), stress-test with hostile content before shipping | judgment | active |
+| D12 | one accent moment per card: brand accent for the primary action only, gold for confidence/progress fills, green only for completed; everything else tonal | judgment | active |
+| D13 | motion is calm and eased: 120-300ms ease-out on opacity/transform only, loops match a measured source cadence, prefers-reduced-motion always freezes them | judgment | active |
+
+Measured recipes live in the mimic studies: `~/arena/mimic-beautiful-ui/LESSONS.md` (18 AI-interface components with exact tokens) and its `remix.css` :root block (the portable Atris token sheet, coffee + paper themes). Start there before designing an agent surface.
 
 ## Self-Improve (part of the job)
 

package/atris/skills/engines/SKILL.md

@@ -1,54 +1,85 @@
 ---
 name: engines
-description: "Dispatch coding work to an installed terminal agent — Codex, Cursor, Devin, Grok, or Atris Fast — as an interchangeable worker engine. Claude orchestrates: writes the bounded prompt, the engine builds, Claude verifies and lands. Triggers on: use codex, use cursor, use devin, use grok, use atris, engine, dispatch to, worker agent, second opinion build."
-version: 1.2.0
+description: "Dispatch work to an installed terminal agent or named Atris engine profile. Supports Atris Fast, Claude, Codex, Cursor, Fable, Composer, Haiku, Devin, Grok, and Droid. Triggers on: use codex, use cursor, use devin, use grok, use fable, use claude, use atris, engine, dispatch to, worker agent, second opinion build."
+version: 1.3.1
 tags:
   - engines
+  - claude
   - codex
   - cursor
+  - fable
+  - composer
+  - haiku
   - devin
   - grok
+  - droid
   - atris
   - orchestration
 ---
 
 # Engines — interchangeable terminal workers
 
-One contract, five engines. The orchestrator (you, Claude) writes a bounded task prompt, dispatches it to an engine, then **independently verifies, lands, and pushes** the result. Engines never self-certify.
+One contract, ten live profiles. The orchestrator writes a bounded task prompt, dispatches it to an engine, then **independently verifies, lands, and pushes** the result. Engines never self-certify.
 
-## Invocation
+## three verbs
+
+- ask: `atris engine <name> "<question>"`; pin a model with `atris engine <name> --model <model> "<question>"`
+- build: `atris engine <name> <task-id>`
+- switch: `atris engine <name>`
+
+## Raw binary fallback and debugging
+
+Raw spawns are not the default because they skip Atris receipts, watch, and coaching.
 
 | Engine | Command | Notes |
 |--------|---------|-------|
-| Codex | `node "${CLAUDE_PLUGIN_ROOT}/scripts/codex-companion.mjs" task --background [--write] "<prompt>"` (via codex plugin / codex:codex-rescue agent) | Poll with `status`, fetch with `result <job-id>` |
+| Atris Fast | `atris chat --print "<prompt>"` (equivalently `ax --fast --print`) | Local tool runtime over the api.atris.ai fast lane. Best for bounded lookups and small verified edits. |
+| Claude | `claude -p "<prompt>"` | Uses the local Claude configuration. Add `--model opus` for maximum-depth review or `--model sonnet` for speed. |
+| Codex | `codex exec --dangerously-bypass-approvals-and-sandbox -o <result-file> "<prompt>"` (run from the target repo/worktree; read-only research: `--sandbox read-only`) | Headless, exits when done — run it as a tracked background Bash task like the other engines and completion auto-wakes the session. Final answer lands in the `-o` file. Verified live 2026-08-11. Outside a git repo add `--skip-git-repo-check` or it exits 1. ONE-SHOT SESSIONS (`claude -p` workers): run codex in the FOREGROUND and wait — a one-shot session never wakes again, so backgrounding strands the result (observed 2026-08-11). The old plugin path (`codex-companion.mjs task --background`) is deprecated for dispatch: its job store never notifies the session (a finished result sat unread overnight, 2026-08-10) |
 | Cursor | `cursor-agent --trust -p "<prompt>"` (run from the target repo) | Headless print mode; `--trust` required for non-interactive |
+| Fable | `claude -p "<prompt>" --model opus` | Maximum-depth Claude review. The `fable` Atris profile is the leader lane and uses the installed Claude CLI. |
+| Composer | `atris run "<objective>" --engine composer` | Fast navigator/executor profile routed through the installed `ax` binary. |
+| Haiku | `claude -p "<prompt>" --model claude-haiku-4-5` | Fast validation and bounded read-only checks. |
 | Devin | `devin -p --permission-mode dangerous -- "<prompt>"` (run from the target repo) | Default permission mode is read-only for writes — build work NEEDS `--permission-mode dangerous`, so only run it in an isolated worktree. Also `devin cloud` for sessions that outlive this machine. Supports `--model swe-1.7` |
-| Grok | `grok --always-approve -p "<prompt>"` (run from the target repo) | Headless single-turn via `-p`; default model grok-4.5. Very fast on lookups (~10s, reads MAP first). Great for quick second opinions; use `--best-of-n <N>` for tricky bounded builds. Uses grok.com login |
-| Atris Fast | `atris chat --print "<prompt>"` (run from the target repo; equivalently `ax --fast --print`) | Headless JSON result `{ok, model, output, durationMs}`; exit 0 = ok. Serves via the api.atris.ai fast lane (glm-5.2) with a local tool runtime scoped to the cwd — reads, greps, small verified edits. ~1% of frontier cost, typical turns 5–40s |
+| Grok | `grok --always-approve -p "<prompt>"` (run from the target repo) | Headless single-turn via `-p`; default model grok-4.6. Very fast on lookups (~5-10s, reads MAP first). Great for quick second opinions; use `--best-of-n <N>` for tricky bounded builds. Uses grok.com login |
+| Droid | `droid exec "<prompt>"` | Executor profile using Droid's built-in router. Use only when the binary is ready in `atris engine --help`. |
+
+Headless dispatch permissions (verified 2026-08-11): `codex exec`, `grok`, and `cursor-agent` are allowlisted in `~/.claude/settings.json` so fresh and one-shot sessions can dispatch without a human approval click. A cold session that gets "requires approval" on an engine command means that allowlist regressed.
 
 ## Picking an engine
 
+- **Atris Fast** — cheap bounded lookups, single-file facts, small verified edits, and high-volume fan-out.
+- **Claude / Fable** — deep review, synthesis, validation, and complex builds. Use Fable when judgment quality matters most.
 - **Codex** — deep root-cause work, long autonomous builds, second-opinion diagnosis. Slowest; runs sandboxed.
 - **Cursor** — fast bounded edits and refactors in a single repo.
+- **Composer / Haiku** — fast, bounded navigation, edits, and validation where a max-tier model would be wasteful.
 - **Devin** — multi-step feature work; use `cloud` when the run should survive laptop sleep.
-- **Grok** - fastest frontier lookups and quick second opinions (grok-4.5, ~10s; reads MAP first); use `--best-of-n` for tricky bounded builds. Uses grok.com login.
-- **Atris Fast** — cheap bounded lookups, single-file facts, small verified edits, high-volume fan-out (ten questions = ten `--print` calls at pennies). Not for multi-file features or long builds. Use it before burning a frontier engine on grunt work.
+- **Grok** - fastest frontier lookups and quick second opinions (grok-4.6, ~5-10s; reads MAP first); use `--best-of-n` for tricky bounded builds. Uses grok.com login.
+- **Droid** — executor work through its built-in router when installed.
 - Parallel builds across repos: one engine job per repo, never two engines writing the same checkout.
 
-## Models worth pinning (verified live 2026-07-09)
+## Models worth pinning (verified live 2026-08-12)
 
 Each engine CLI can pin a specific model. Current best picks:
 
 | Engine | Flag | Best models today |
 |--------|------|-------------------|
+| Claude / Fable | `--model opus` | `opus` currently resolves to Opus 5; use the explicit Opus 4.8 identifier only for reproducibility |
 | Devin | `--model swe-1.7` | `swe-1.7` (free right now: use it as the volume executor for parallel bounded slices), `swe-1.7-lightning` for speed |
-| Cursor | `--model grok-4.5-xhigh` | `grok-4.5-xhigh` / `grok-4.5-fast-xhigh` for second-opinion builds, `composer-2.5` for fast edits; parameterized Claude via `'claude-opus-4-8[effort=high]'`; `--list-models` shows the full menu |
-| Grok | (default) | `grok-4.5` default, `grok-composer-2.5-fast` for speed |
-| Codex | (plugin default) | rides the codex plugin's pinned model |
+| Cursor | `--model cursor-grok-4.6-xhigh` | `cursor-grok-4.6-xhigh` for second-opinion builds, `cursor-grok-4.6-high-fast` for quick pinned asks (answered in ~12s live 2026-08-12), `composer-2.5` for fast edits; parameterized Claude via `'claude-opus-4-8[effort=high]'`; `--list-models` shows the full menu |
+| Composer | `--engine composer` | `composer 2.5` through the Atris profile |
+| Haiku | `--model claude-haiku-4-5` | `haiku` for fast validation |
+| Grok | (default) | `grok-4.6` default (confirmed live 2026-08-12, ~5s lookup), `grok-4.5` still available via `-m` |
+| Codex | `-m <model>` | CLI default rides `~/.codex/config.toml`; pin with `-m` only when the task needs it |
+| Droid | (built-in router) | Let the installed Droid CLI select its model |
 | Atris Fast | (fixed) | api.atris.ai fast lane |
 
 Re-verify this table when a lab ships a new model: run each CLI's model-list command, smoke one lookup, and update the row. Free-tier windows (like swe-1.7 now) are the moment to fan out volume work.
 
+## Keep the local roster current
+
+Run `atris engine doctor`, then `atris engine --help`. The canonical profiles live in `lib/runner-command.js`; tiers, roles, models, duties, and health live in `lib/engine-registry.js`. When this guide and the live roster disagree, the registry is the source of truth and this guide must be updated.
+
 ## Atris Fast runtime requirements (verified live 2026-07-03)
 
 - Must run from an **initialized Atris workspace** (an `atris/` folder) under an allowed workspace root (e.g. `~/arena/*`). `atris chat --print` outside one exits 1 with "Run atris init"; `ax --fast --print` outside an allowed root fail-closes with `{ok:false, error:"workspace_path must be under an allowed local workspace root"}`.

package/atris/team/customer-lead/MEMBER.md

@@ -0,0 +1,45 @@
+---
+name: customer-lead
+role: Customer Lead
+description: Keeps customer commitments visible, spots retention risk, and turns evidence into the next useful follow-up.
+version: 1.0.0
+
+skills:
+  - customer-commitments
+
+permissions:
+  can-read: true
+  can-execute: true
+  can-approve: false
+  can-send: false
+  approval-required:
+    - send
+    - publish
+    - commercial-promise
+
+tools: []
+---
+
+# Customer Lead
+
+## Persona
+
+Warm, concise, and exact about follow-through. Customer Lead starts with what
+the customer is trying to achieve, separates evidence from assumptions, and
+raises a broken commitment before it becomes a broken relationship.
+
+## Workflow
+
+1. Read the available customer messages, feedback, notes, tasks, and receipts.
+2. Name the desired outcome, latest signal, open commitment, owner, due date, and evidence for each customer in scope.
+3. Mark each commitment on track, needs attention, broken, or unknown without inventing a health score.
+4. Draft the smallest recovery or follow-up that moves the customer's outcome forward, routing product work into the existing task or feedback queue.
+5. Record the next commitment and proof target, then ask for human approval before any external message or commercial promise.
+
+## Rules
+
+1. Never send a message, issue a credit, or promise price, timing, or roadmap work without human approval.
+2. Use real evidence only. Missing data stays unknown, and silence alone is not proof of churn.
+3. Own customer outcomes, commitments, and retention risk, not prospecting or product-feedback synthesis.
+4. Prefer one clear next commitment over account theater, generic check-ins, or a heavyweight review process.
+5. Expansion follows proven value and explicit customer need; never push it to repair weak retention.

package/atris/team/customer-lead/SOUL.md

@@ -0,0 +1,33 @@
+---
+name: customer-lead
+version: 1.0.0
+born: 2026-08-11
+---
+
+# Soul
+
+## Beliefs
+
+- Customers experience the company through the promises it keeps.
+- A small missed commitment can predict lost trust earlier than a large dashboard.
+- Unknown evidence should remain unknown until a real signal resolves it.
+- Retention is earned by useful outcomes and honest follow-through, not by more meetings.
+
+## Values
+
+1. Trust through follow-through.
+2. Early, grounded evidence.
+3. Restraint before external action.
+
+## Lessons
+
+- No earned lessons yet.
+
+## Edges
+
+- **Strong:** Turns scattered customer signals into explicit owners, dates, risks, and next actions.
+- **Weak:** Can overread silence or loud feedback, so it seeks confirmation before escalating a conclusion.
+
+## Voice
+
+- What did we promise, what evidence says it helped, and what must happen next?

package/atris/team/customer-lead/START_HERE.md

@@ -0,0 +1,7 @@
+# Start Here - Customer Lead
+
+1. Read the current customer evidence and name which customer or segment is in scope.
+2. Open the existing feedback and task queues so customer work is not duplicated.
+3. Build the commitment view with an outcome, evidence, owner, due date, state, and next action.
+4. Draft one useful follow-up or recovery step and stop for approval before anything leaves the workspace.
+5. Close with the commitment recorded and a proof target for the next check.

package/atris/team/customer-lead/skills/customer-commitments/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: customer-commitments
+description: Turn real customer evidence into a compact commitment view, retention risk, and one approval-gated next action. Use when reviewing customer feedback, follow-ups, promises, churn signals, or retention risk.
+version: 1.0.0
+tags:
+  - customer-success
+  - retention
+  - commitments
+---
+
+# Customer Commitments
+
+Use this skill when a customer outcome, promise, follow-up, or retention risk
+needs an owner and a trustworthy next action.
+
+## Workflow
+
+1. Read only the customer evidence available in the workspace.
+2. Record the customer, desired outcome, latest signal, commitment, owner, due date, state, source, and confidence.
+3. Use only four states: on track, needs attention, broken, or unknown.
+4. Draft one next action tied to the desired outcome and existing evidence.
+5. Route product defects or requests into the existing feedback or task system.
+6. Stop for human approval before sending, publishing, discounting, refunding, or making a commercial or roadmap promise.
+
+## Guardrails
+
+- Never manufacture usage, sentiment, renewal, or revenue data.
+- Never replace missing evidence with a composite health score.
+- Never create a parallel product backlog from customer notes.
+- Keep the view small enough that an owner can see the next commitment immediately.
+
+## Example
+
+Input: "The customer asked about exports last week, and we promised an answer by Friday."
+
+Output: Record the customer's export outcome, the dated request as evidence,
+the promised answer and its owner, Friday as the due date, the state as needs
+attention, and one approval-gated follow-up. Leave any missing owner or customer
+sentiment unknown.
+
+## Troubleshooting
+
+- If sources conflict, show both signals, lower confidence, and ask the owner to resolve them.
+- If no owner or due date exists, mark it unknown and propose one for approval.
+- If the next action is product work, link or update the existing task instead of opening a parallel backlog.

package/atris/team/improver/MEMBER.md

@@ -0,0 +1,33 @@
+---
+name: improver
+role: Improver
+description: Proposes guarded member and workflow improvements from evidence.
+version: 1.0.0
+runtime-alias: architect
+
+skills: []
+
+permissions:
+  can-read: true
+  can-execute: true
+  can-approve: false
+
+tools: []
+---
+
+# Improver
+
+Suggests better member behavior without applying risky changes automatically.
+
+## Workflow
+
+1. Read causal evidence, reusable patterns, logs, and receipts.
+2. Pick one behavior or workflow improvement.
+3. Propose a small overlay or task.
+4. Wait for approval before changing durable member specs.
+
+## Rules
+
+- Advisory by default.
+- Prefer overlays over base spec rewrites.
+- Every recommendation needs evidence and a rollback path.

package/bin/atris.js

@@ -465,6 +465,13 @@ function showHelp() {
   console.log('  atris init [--yes]        Global install: initialize this project');
   console.log('  npx atris init [--yes]    Local install: initialize this project');
   console.log('  atris computer');
+  console.log('  atris ask "what you want" [--budget <usd>]');
+  console.log('  atris mission              Show the current mission');
+  console.log('  atris approve              Approve the step waiting for you');
+  console.log('  atris stop                 Stop the current mission');
+  console.log('  atris check <run-id>       Show the checks for a mission');
+  console.log('  atris ready --json         Show which mission features are ready');
+  console.log('  atris engine validate latest  check the newest ask receipt with a cheap referee');
   console.log('  atris business init "My Company"');
   console.log('  atris run');
   console.log('  atris drill');
@@ -500,6 +507,7 @@ function showHelp() {
   console.log('  wish       - Say one plain sentence, then Atris asks only for gaps or delegates it');
   console.log('  now        - Show atris/now.md, the current operating truth');
   console.log('  goal       - goal, distance, and what moved today (alias: wtf)');
+  console.log('  founder    - show weekly commit and completed-task improvement from receipts');
   console.log('  orb        - Pick next moves while engine jobs work in the background');
   console.log('  activate   - Load Atris context');
   console.log('  radar      - Show live agents joined with tasks, missions, and worktrees');
@@ -553,9 +561,10 @@ function showHelp() {
   console.log('  improve    - Run one paid RL tick (POST /api/improve, deducts credits)');
   console.log('  worktree   - Isolated Git worktrees plus guarded ship/merge for parallel agents');
   console.log('  land       - The landing: what is actually done vs still in the air; --reap backs up + clears overdue');
+  console.log('  caretaker  - Classify open pull requests on origin (scan only; no fix, comment, or merge)');
   console.log('  drive      - One self-driving tick: mission doctor -> auto-fix -> count disengagements');
   console.log(`  autoland   - Approve the policy once; ${require('../lib/autoland').certifiedWorkLandsPhrase(process.cwd())}, you keep irreversible calls`);
-  console.log('  engine     - Engine registry: list/resolve roles, health flips, default engine, `engine test`, and dispatch flights');
+  console.log('  engine     - engine registry, answer validation, dispatch flights, and live progress');
   console.log('  router     - inspect ax lane outcomes and promote gated reflex overrides');
   console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
   console.log('  visualize  - Generate a Slack/deck-ready visual from a prompt');
@@ -1844,6 +1853,22 @@ if (command === 'init') {
   Promise.resolve(require('../commands/decide').decideCommand(process.argv.slice(3)))
     .then(() => exitAfterStdoutDrain(process.exitCode || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); exitAfterStdoutDrain(1); });
+} else if (
+  ['ask', 'approve', 'stop', 'ready', 'check'].includes(command)
+  || (command === 'proof' && process.argv.slice(3).every((value) => String(value).startsWith('-')))
+) {
+  const humanCommands = require('../commands/human-missions');
+  const handlers = {
+    ask: humanCommands.askCommand,
+    approve: humanCommands.approveCommand,
+    stop: humanCommands.stopCommand,
+    ready: humanCommands.readyCommand,
+    check: humanCommands.checkCommand,
+    proof: humanCommands.proofCommand,
+  };
+  Promise.resolve(handlers[command](process.argv.slice(3)))
+    .then((code) => exitWhenFlushed(Number.isInteger(code) ? code : (process.exitCode || 0)))
+    .catch((err) => { console.error(`\nAtris could not finish that request: ${err.message || err}`); exitWhenFlushed(1); });
 } else if (command === 'mission') {
   // process.exit() can outrun a piped stdout: writes beyond the 64KB pipe
   // buffer are async, so large --json payloads truncate at 64KB multiples.
@@ -1886,6 +1911,10 @@ if (command === 'init') {
   Promise.resolve(require('../commands/land').landCommand(process.argv.slice(3)))
     .then((code) => process.exit(code || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'caretaker') {
+  Promise.resolve(require('../commands/caretaker').caretakerCommand(process.argv.slice(3)))
+    .then((code) => process.exit(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
 } else if (command === 'close') {
   Promise.resolve(require('../commands/close').run(process.argv.slice(3)))
     .then((code) => process.exit(typeof code === 'number' ? code : 0))
@@ -1894,6 +1923,10 @@ if (command === 'init') {
   Promise.resolve(require('../commands/goal').run(process.argv.slice(3)))
     .then((code) => process.exit(typeof code === 'number' ? code : 0))
     .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
+} else if (command === 'founder') {
+  Promise.resolve(require('../commands/founder').founderCommand(process.argv.slice(3)))
+    .then((code) => process.exit(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\nerror: ${err.message || err}`); process.exit(1); });
 } else if (command === 'drive') {
   // Drive: one self-driving tick — mission doctor -> auto-fix safe findings -> count disengagements.
   Promise.resolve(require('../commands/drive').driveCommand(process.argv.slice(3)))
@@ -2821,9 +2854,9 @@ if (command === 'init') {
     .then(() => process.exit(process.exitCode || 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'engine' || command === 'engines') {
-  // Engine: bring any intelligence — roster of installed coding CLIs, default
+  // Engine: bring any intelligence. Roster of installed coding CLIs, default
   // engine per workspace, --engine <name> rides any loop for one run.
-  // `engine dispatch` runs an async claim -> build -> ship flight, so the
+  // `engine dispatch`, `engine ask`, `engine validate`, and `engine watch` can be async, so the
   // return value may be a promise or a plain number; Promise.resolve handles
   // both (mirrors the `compile` command dispatch just above).
   const engineArgs = command === 'engines' && process.argv.length <= 3 ? [] : process.argv.slice(3);

package/commands/autoland.js

@@ -8,6 +8,7 @@ const { spawnSync } = require('child_process');
 const autoland = require('../lib/autoland');
 const { gateForHuman, plainLandingReason } = require('../lib/voice-gate');
 const { evaluateAutoAccept } = require('../lib/auto-accept-certified');
+const { sweepEngineAskReceipts } = require('../lib/engine-receipt-sweep');
 const { operatorReady, hasAgentJargon, explainResult } = autoland;
 const MISSION_AUTO_VERIFY_STATUSES = new Set(['planning', 'paused', 'ready']);
 const CLOSED_TASK_STATUSES = new Set(['done', 'archived']);
@@ -713,8 +714,20 @@ function digestTickStatus(receipt) {
   return 'not due';
 }
 
+function engineReceiptSweepNote(receipt) {
+  const finalized = Number(receipt.engine_receipt_sweep?.finalized) || 0;
+  if (!finalized) return '';
+  return `, finalized ${finalized} stale engine receipt${finalized === 1 ? '' : 's'} as presumed dead`;
+}
+
 function runTickBody(root, { json, policy, receipt }) {
 
+  try {
+    receipt.engine_receipt_sweep = sweepEngineAskReceipts(root);
+  } catch (err) {
+    receipt.engine_receipt_sweep_error = String((err && err.message) || err).slice(0, 200);
+  }
+
   // 1. certify and land in one task process. Keeping both phases together lets
   // the landing gate reuse the live certification verifier result without
   // persisting trust across heartbeats. Denied lanes and check-less proofs wait.
@@ -983,13 +996,14 @@ function runTickBody(root, { json, policy, receipt }) {
     const janitorNote = `, janitor stopped ${receipt.missions_stopped} mission${receipt.missions_stopped === 1 ? '' : 's'} + reaped ${receipt.worktrees_reaped} worktree${receipt.worktrees_reaped === 1 ? '' : 's'}`;
     const heldNote = receipt.missions_held ? `, held ${receipt.missions_held} human-blocked mission${receipt.missions_held === 1 ? '' : 's'}` : '';
     const wishNote = `, ${wishSweepSummaryLine(receipt.wish_dispatch, receipt.wish_dispatch_error)}`;
+    const engineSweepNote = engineReceiptSweepNote(receipt);
     const receiptNote = receipt.receipt_path ? `, receipt ${receipt.receipt_path}` : '';
     // Deltas alone ("0 certified, 0 landed") are true and useless: they read
     // as "nothing to do" whether the queue is empty or 19-deep and wedged.
     // Always print the standing backlog, and name work that cleared every
     // gate and still did not land — that is the shape of a stuck loop.
     const stuckNote = stuckBacklogNote(receipt);
-    const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms${stuckNote}, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${receiptNote}`;
+    const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms${stuckNote}, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${engineSweepNote}${receiptNote}`;
     console.log(gateForHuman(summary).text);
     for (const fulfilled of receipt.wish_dispatch?.fulfilled_results || []) {
       if (fulfilled.review_ask) console.log(fulfilled.review_ask);