Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

Merge batch 11-03 bb: #2666 #2659 (#2667)

0xken154e0369455271
diff --git a/backend/src/superTabs/commands.ts b/backend/src/superTabs/commands.ts
index 006443d40..cbb4fdd0d 100644
--- a/backend/src/superTabs/commands.ts
+++ b/backend/src/superTabs/commands.ts
@@ -19,7 +19,7 @@ import { MAX_ATTACHMENTS, type Attachment } from './attachments.js'
import { checkMentions, MAX_MENTIONS, namedIn, saysName, textTags, withTags, type MentionTarget } from './mentions.js'
import { answerDecision, askDecisions, checkAsker, decisionChoices, decisionQuestion, MAX_OPEN_DECISIONS, MAX_QUESTIONS, type DecisionTarget } from './decisions.js'
import { leadOf, TERMINAL_KEYS, terminalAlert, terminalRequest, terminalResult, toLead, type TerminalRequest } from './terminal.js'
-import { changesRequested, leadNoticeRows, loseTasks, recordTaskState, renewLease, renewOwnTask, restartQuietTime, revisionReady, waitingForReview } from './liveness.js'
+import { changesRequested, engineerAnswered, leadNoticeRows, loseTasks, recordTaskState, renewLease, renewOwnTask, restartQuietTime, revisionReady, toldEngineer, waitingForReview } from './liveness.js'
import { DELETED_SWARM_COMMANDS, isPersonalSwarm, notThere, SWARM_DELETE_GRACE_MS } from './deletion.js'
import { ABANDONED, askedModel, coordinatorCopy, failureNotice, failureRecipients, MACHINE_REMOVED } from './startFailure.js'
import { noteStartFailed, noteStartSucceeded, resumeEngine } from './engineHealth.js'
@@ -2842,6 +2842,9 @@ function applyCommandOnce(original: SuperTabState, actor: Actor, input: Command,
if (session?.inSession) Object.assign(effects.messages.at(-1)!, { buddySession: true, ...(session.project ? { buddyProject: session.project } : {}) })
recordPost(state, group, actor, { replyTo: command.replyTo, text, reply: context.reply, openTags: context.openTags }, context.now)
if (actor.kind === 'agent') renewOwnTask(state, group, actor.agentId, context.now)
+ // A verdict is usually a post to the Engineer: its own step then waits for the new revision (liveness.ts waitingForRevision).
+ if (actor.kind === 'agent') toldEngineer(state, group, actor.agentId, recipients, text, context.now)
+ if (actor.kind === 'agent') engineerAnswered(state, group, actor.agentId, recipients, context.now)
leadActed(group.id, 'post')
break
}
diff --git a/backend/src/superTabs/liveness.test.ts b/backend/src/superTabs/liveness.test.ts
index 26af04773..342da3cb1 100644
--- a/backend/src/superTabs/liveness.test.ts
+++ b/backend/src/superTabs/liveness.test.ts
@@ -131,6 +131,39 @@ describe('a review task while its build is back with the Engineer', () => {
expect(sweep(reviewing(later, { status: 'review', result: 'Ready for review at abc1234' }, {}, {}), later)).toEqual({ status: 'lost', lost: true })
})
+ // Task #2241: Reviewers give their verdict as a post, and stay Working while the Engineer fixes it (instructions, revision 27).
+ const told = { toldEngineerAt: asked }
+ it('keeps its task through 35 quiet minutes after writing to its Engineer, while the Engineer is fixing', () => {
+ for (const status of ['working', 'blocked', 'needs_human'] as const) expect(sweep(reviewing(later, { status }, {}, told), later)).toEqual({ status: 'working', lost: false })
+ expect(nextLossAt(reviewing(later, {}, {}, told), 'm')).toBeUndefined()
+ })
+
+ it('holds nothing when its Engineer is waiting on a review: "starting now", then silence, still moves', () => {
+ const waiting = reviewing(later, { status: 'review', result: 'Ready for review at abc1234' }, {}, told)
+ expect(sweep(waiting, later)).toEqual({ status: 'lost', lost: true })
+ expect(review(waiting).lost?.reason).toBe('no progress for 35 minutes')
+ // An older skill's hand-off is working by status, and waits on a review all the same.
+ expect(sweep(reviewing(later, { status: 'working', result: 'Ready for review at abc1234' }, {}, told), later)).toEqual({ status: 'lost', lost: true })
+ })
+
+ it('has 30 minutes from the Engineer\'s next Ready, and is moved after them', () => {
+ const ready = (at: number) => {
+ const state = reviewing(at, { status: 'review', result: 'Ready for review at abc1234', progressAt: later }, {}, told)
+ revisionReady(state, group(state, 'g1'), later)
+ return state
+ }
+ expect(review(ready(later)).toldEngineerAt).toBeUndefined()
+ expect(sweep(ready(later + QUIET_RUNNING_MS), later + QUIET_RUNNING_MS)).toEqual({ status: 'working', lost: false })
+ expect(sweep(ready(later + QUIET_RUNNING_MS + 1), later + QUIET_RUNNING_MS + 1)).toEqual({ status: 'lost', lost: true })
+ })
+
+ it('still loses its task at once when its session stops or its machine goes, and to time once its build ends', () => {
+ const stopped = reviewing(later, {}, {}, told)
+ stopped.machines![0]!.observation!.stoppedHarnessIds = ['h']
+ expect(sweep(stopped, later)).toEqual({ status: 'lost', lost: true })
+ for (const status of ['cancelled', 'done', 'lost'] as const) expect(sweep(reviewing(later, { status }, {}, told), later)).toEqual({ status: 'lost', lost: true })
+ })
+
it('still loses its task to time once its build is cancelled, finished, lost, archived, unloaded or in another project', () => {
for (const status of ['cancelled', 'done', 'lost'] as const) expect(sweep(reviewing(later, { status }), later)).toEqual({ status: 'lost', lost: true })
expect(sweep(reviewing(later, {}, { archived: true }), later)).toEqual({ status: 'lost', lost: true })
diff --git a/backend/src/superTabs/liveness.ts b/backend/src/superTabs/liveness.ts
index adefa258a..da6ef3cce 100644
--- a/backend/src/superTabs/liveness.ts
+++ b/backend/src/superTabs/liveness.ts
@@ -111,9 +111,45 @@ function ownLinkedTasks(state: SuperTabState, build: Conversation, agentId: stri
/** A linked task waits for the new revision from its own Reviewer's verdict asking for changes until the build's next Ready,
* while that build is still active, so its quiet time does not count then (Diego, 2026-11-01: a Reviewer waiting on a normal
* fix round of ~31 minutes lost its task, its Lead was woken and its verdict refused). It follows the Reviewer, never the
- * Engineer: an Engineer's own posts or "working" heartbeats keep no idle Reviewer (review of #2487). */
+ * Engineer: an Engineer's own posts or "working" heartbeats keep no idle Reviewer (review of #2487). A verdict is usually a
+ * post to the Engineer, which holds only while the Engineer isn't itself waiting on a review, so a "starting now" followed by
+ * silence still moves (#2241: 35 attempts lost in a day). */
export function waitingForRevision(state: SuperTabState, group: Conversation): boolean {
- return group.assignment?.changesRequestedAt !== undefined && !!reviewedBuild(state, group)
+ const build = reviewedBuild(state, group)
+ if (!build) return false
+ const assignment = group.assignment
+ return assignment?.changesRequestedAt !== undefined || (assignment?.toldEngineerAt !== undefined && !waitingForReview(build.assignment!))
+}
+
+/** The Reviewer's verdict asking for changes, in the form the project's reviewers write (code-reviewer.md). */
+const ASKS_FOR_CHANGES = /ready to merge:\W*(no|with fixes)\b/i
+
+/** [agentId] wrote to its Engineer, in its own linked task's chat or in the build's: it may now wait for the new revision
+ * (waitingForRevision), if the Engineer was waiting on this review (a Tester's verdict has no set form), or it asks for changes
+ * while the Engineer already fixes someone else's. A note to a working Engineer keeps no Reviewer that then hangs. Written in
+ * that post's own write. */
+export function toldEngineer(state: SuperTabState, group: Conversation, agentId: string, recipients: string[], text: string, now: number): void {
+ const own = activeWork(group) && group.assignment!.agentId === agentId && reviewedBuild(state, group) ? [group] : ownLinkedTasks(state, group, agentId)
+ for (const step of own) {
+ const engineer = reviewedBuild(state, step)!.assignment!
+ if (!recipients.includes(engineer.agentId) || !(waitingForReview(engineer) || ASKS_FOR_CHANGES.test(text))) continue
+ step.assignment!.toldEngineerAt = now
+ recordTaskState(state, step, now)
+ }
+}
+
+/** The Engineer [agentId] wrote to a step's agent waiting for its revision, in the step's chat or the build's: a "fixed at abc,
+ * please re-check" is a Ready by post, so that wait ends and its 30 minutes run from now (review of #2659). A step not waiting
+ * gets no time from it: an Engineer's posts keep no idle Reviewer (review of #2487). */
+export function engineerAnswered(state: SuperTabState, group: Conversation, agentId: string, recipients: string[], now: number): void {
+ const steps = group.reviewOf ? [group] : state.conversations.filter(c => c.reviewOf === group.id)
+ for (const step of steps) {
+ if (!activeWork(step) || step.assignment!.toldEngineerAt === undefined || !recipients.includes(step.assignment!.agentId)) continue
+ if (reviewedBuild(state, step)?.assignment!.agentId !== agentId) continue
+ delete step.assignment!.toldEngineerAt
+ restartQuietTime(step.assignment!, now)
+ recordTaskState(state, step, now)
+ }
}
/** [agentId]'s verdict in [build] asked for changes (a failed check by someone other than its assignee): its own linked task
@@ -128,8 +164,9 @@ export function changesRequested(state: SuperTabState, build: Conversation, agen
/** [build] is ready for review again: each linked task that waited for this revision counts its quiet time from now, so the end
* of the wait does not lose it, as an Engineer whose review found problems does (restartQuietTime). */
export function revisionReady(state: SuperTabState, build: Conversation, now: number): void {
- for (const linked of state.conversations.filter(c => c.reviewOf === build.id && activeWork(c) && c.assignment!.changesRequestedAt !== undefined)) {
+ for (const linked of state.conversations.filter(c => c.reviewOf === build.id && activeWork(c) && (c.assignment!.changesRequestedAt !== undefined || c.assignment!.toldEngineerAt !== undefined))) {
delete linked.assignment!.changesRequestedAt
+ delete linked.assignment!.toldEngineerAt
restartQuietTime(linked.assignment!, now)
recordTaskState(state, linked, now)
}
diff --git a/backend/src/superTabs/model.ts b/backend/src/superTabs/model.ts
index 010fdaf5f..a35c59c29 100644
--- a/backend/src/superTabs/model.ts
+++ b/backend/src/superTabs/model.ts
@@ -230,6 +230,9 @@ export interface Assignment {
/** On a linked task (reviewOf): when its own Reviewer's verdict in the build asked for changes. Its quiet time does not count
* until the build's next Ready clears it (liveness.ts waitingForRevision). */
changesRequestedAt?: number
+ /** On a linked task: when its agent last wrote to the build's Engineer, as a verdict usually is. It holds the quiet time while
+ * the Engineer isn't waiting on a review, until the build's next Ready clears it (liveness.ts waitingForRevision). */
+ toldEngineerAt?: number
/** A two-review task's hand-overs and reviewers' verdicts, from the automatic reviews (#2382) before project instructions;
* never written since (phase 4: the server opens and counts no review), kept on older rows. */
handoffs?: number
diff --git a/backend/src/superTabs/parts/light.test.ts b/backend/src/superTabs/parts/light.test.ts
index 3e898aded..9b1934c41 100644
--- a/backend/src/superTabs/parts/light.test.ts
+++ b/backend/src/superTabs/parts/light.test.ts
@@ -8,7 +8,7 @@ import { FINISHED, GROUP_FIELDS } from './light.js'
* here, and the test below until light.ts either projects it or names it as unread by reads (review of #1745). */
const assignment: Required<Assignment> = {
id: 'w', agentId: 'a', status: 'working', configuration: { engine: 'codex', model: null, effort: null, contextWindow: null, engineVersion: null },
- execution: { machineId: 'm', harnessId: 'h', machineOwnerId: 'o' }, result: null, recordingProgress: { at: 1, revision: 1 }, leaseUntil: 1, progressAt: 1, askedOf: 'p', reviewFoundAt: 1, changesRequestedAt: 1,
+ execution: { machineId: 'm', harnessId: 'h', machineOwnerId: 'o' }, result: null, recordingProgress: { at: 1, revision: 1 }, leaseUntil: 1, progressAt: 1, askedOf: 'p', reviewFoundAt: 1, changesRequestedAt: 1, toldEngineerAt: 1,
handoffs: 1, verdicts: [{ by: 'agent:r', passed: true, handoff: 1, review: 'g' }], lost: { reason: 'r', at: 1 },
}
const conversation: Required<Conversation> = {
diff --git a/backend/src/superTabs/parts/light.ts b/backend/src/superTabs/parts/light.ts
index 4f4d1b596..42b75ad19 100644
--- a/backend/src/superTabs/parts/light.ts
+++ b/backend/src/superTabs/parts/light.ts
@@ -28,7 +28,7 @@ export const GROUP_FIELDS = {
'assignment.lost'],
whenRunning: ['title', 'task.owns', 'assignment.execution', 'assignment.result'],
unread: ['number', 'brief', 'reviewOf', 'teamWritten', 'step', 'reviewStamp', 'checks', 'lastMessageSequence', 'lastMainSequence', 'pullRequestUrls', 'cards', 'messageSeq', 'reportSeq', 'lastActivityAt', 'lostAttempt', 'requesterId', 'ledger', 'reactionSeq', 'proposals', 'buddyName', 'buddySessions', 'buddyDownTold', 'liveness', 'leadAction', 'stepUp',
- 'assignment.configuration', 'assignment.recordingProgress', 'assignment.leaseUntil', 'assignment.progressAt', 'assignment.askedOf', 'assignment.reviewFoundAt', 'assignment.changesRequestedAt',
+ 'assignment.configuration', 'assignment.recordingProgress', 'assignment.leaseUntil', 'assignment.progressAt', 'assignment.askedOf', 'assignment.reviewFoundAt', 'assignment.changesRequestedAt', 'assignment.toldEngineerAt',
'assignment.handoffs', 'assignment.verdicts'],
} as const
const LIGHT_GROUP = {
diff --git a/backend/src/superTabs/steps.test.ts b/backend/src/superTabs/steps.test.ts
index d8473ef1b..fd03cba91 100644
--- a/backend/src/superTabs/steps.test.ts
+++ b/backend/src/superTabs/steps.test.ts
@@ -102,6 +102,95 @@ describe('assigning a step', () => {
expect(f.group(id).assignment!.id).not.toBe(first)
})
+ // Task #2241: a verdict is a post, in the step's chat or the task's, addressed to the Engineer.
+ describe('a post to its Engineer', () => {
+ const post = (f: ReturnType<typeof stepsFixture>, conversationId: string, recipientIds: string[], actor: string) =>
+ f.run({ type: 'message.send', conversationId, text: 'Ready to merge: No. One Critical.', replyTo: null, recipientIds } as Command, f.as(actor))
+ const reviewing = () => {
+ const f = stepsFixture()
+ const id = f.step('Review')
+ const rev = f.add('rev', id)
+ f.run({ type: 'work.assign', conversationId: id, agentId: rev }, f.as(f.dev))
+ return { f, id, rev }
+ }
+
+ it('from the step\'s own agent is kept, in the step\'s chat or the task\'s', () => {
+ const a = reviewing()
+ post(a.f, a.id, [a.f.dev], a.rev)
+ expect(a.f.group(a.id).assignment!.toldEngineerAt).toBe(a.f.now)
+ // A plain post in a step reaches its Engineer by default, so it counts too.
+ const b = reviewing()
+ post(b.f, b.id, [], b.rev)
+ expect(b.f.group(b.id).assignment!.toldEngineerAt).toBe(b.f.now)
+ // Named from the task's own chat, once the Reviewer is in it.
+ const c = reviewing()
+ c.f.run({ type: 'conversation.agent', conversationId: c.f.task, agentId: c.rev, present: true, lead: false })
+ post(c.f, c.f.task, [c.f.dev], c.rev)
+ expect(c.f.group(c.id).assignment!.toldEngineerAt).toBe(c.f.now)
+ })
+
+ it('is what counts: not a post to someone else, nor the Engineer\'s own post to the step', () => {
+ const f = reviewing()
+ const other = f.f.add('other', f.id)
+ post(f.f, f.id, [other], f.rev)
+ expect(f.f.group(f.id).assignment!.toldEngineerAt).toBeUndefined()
+ post(f.f, f.id, [f.rev], f.f.dev)
+ expect(f.f.group(f.id).assignment!.toldEngineerAt).toBeUndefined()
+ })
+
+ // An existing rule (integration/superTabLiveness.test.ts): a Reviewer's note to a working Engineer keeps no hung Reviewer.
+ it('holds nothing when it\'s a note to an Engineer already working, but a verdict does', () => {
+ const f = reviewing()
+ const note = (text: string) => f.f.run({ type: 'message.send', conversationId: f.id, text, replyTo: null, recipientIds: [f.f.dev] } as Command, f.f.as(f.rev))
+ note('Still reading the parser changes.')
+ expect(f.f.group(f.id).assignment!.toldEngineerAt).toBeUndefined()
+ note('Ready to merge: Yes, once CI is green.')
+ expect(f.f.group(f.id).assignment!.toldEngineerAt).toBeUndefined()
+ note('**Ready to merge: With fixes.** One Important finding.')
+ expect(f.f.group(f.id).assignment!.toldEngineerAt).toBe(f.f.now)
+ })
+
+ it('counts whatever it says when the Engineer was waiting on this review, as a Tester\'s verdict has no set form', () => {
+ const f = reviewing()
+ f.f.run({ type: 'work.status', conversationId: f.f.task, assignmentId: f.f.group(f.f.task).assignment!.id, status: 'review', result: 'PR 7' } as Command, f.f.as(f.f.dev))
+ f.f.run({ type: 'message.send', conversationId: f.id, text: 'Sign-in fails offline, steps below.', replyTo: null, recipientIds: [f.f.dev] } as Command, f.f.as(f.rev))
+ expect(f.f.group(f.id).assignment!.toldEngineerAt).toBe(f.f.now)
+ })
+
+ // Review of #2659: Engineers often ask by post, "fixed at abc, please re-check", so a hung Reviewer must not stay held.
+ it('ends with the Engineer\'s post to it, in the step\'s chat or the task\'s, and its 30 minutes restart', () => {
+ const a = reviewing()
+ post(a.f, a.id, [a.f.dev], a.rev)
+ a.f.tick(60_000)
+ post(a.f, a.id, [a.rev], a.f.dev)
+ expect(a.f.group(a.id).assignment!.toldEngineerAt).toBeUndefined()
+ expect(a.f.group(a.id).assignment).toMatchObject({ status: 'working', progressAt: a.f.now })
+ const b = reviewing()
+ post(b.f, b.id, [b.f.dev], b.rev)
+ b.f.run({ type: 'conversation.agent', conversationId: b.f.task, agentId: b.rev, present: true, lead: false })
+ b.f.tick(60_000)
+ post(b.f, b.f.task, [b.rev], b.f.dev)
+ expect(b.f.group(b.id).assignment!.toldEngineerAt).toBeUndefined()
+ expect(b.f.group(b.id).assignment).toMatchObject({ progressAt: b.f.now })
+ })
+
+ it('gives no time to a Reviewer that isn\'t waiting: the Engineer\'s posts keep no idle Reviewer', () => {
+ const f = reviewing()
+ const before = f.f.group(f.id).assignment!.progressAt
+ f.f.tick(60_000)
+ post(f.f, f.id, [f.rev], f.f.dev)
+ expect(f.f.group(f.id).assignment!.progressAt).toBe(before)
+ })
+
+ it('ends with the Engineer\'s next Ready', () => {
+ const f = reviewing()
+ post(f.f, f.id, [f.f.dev], f.rev)
+ f.f.run({ type: 'work.status', conversationId: f.f.task, assignmentId: f.f.group(f.f.task).assignment!.id, status: 'review', result: 'PR 7, fixed' } as Command, f.f.as(f.f.dev))
+ expect(f.f.group(f.id).assignment!.toldEngineerAt).toBeUndefined()
+ expect(f.f.group(f.id).assignment).toMatchObject({ status: 'working', progressAt: f.f.now })
+ })
+ })
+
// The fix round Reviewers already wait through (liveness.ts waitingForRevision, Diego 2026-11-01), pinned for steps.
it('stays working across its owner\'s fix round', () => {
const f = stepsFixture()
diff --git a/cli/e2e/superTabTerminal.e2e.ts b/cli/e2e/superTabTerminal.e2e.ts
index cc1b019eb..7895efadd 100644
--- a/cli/e2e/superTabTerminal.e2e.ts
+++ b/cli/e2e/superTabTerminal.e2e.ts
@@ -88,10 +88,10 @@ describe.skipIf(!process.env.HARNESS_E2E_SERVICES_DIR)('a Lead driving a worker\
expect(scrolled.code, scrolled.out).toBe(0)
expect(scrolled.out).toContain('Do you want to proceed?')
- // Only the Lead of the worker's project may: the worker cannot read the Lead's terminal.
+ // A Product Manager's terminal is its owner's: the worker cannot read the Lead's.
const refused = await superTab(W, tab, worker, ['screen', lead])
expect(refused.code).toBe(1)
- expect(JSON.parse(refused.out)).toMatchObject({ error: 'LEAD_REQUIRED' })
+ expect(JSON.parse(refused.out)).toMatchObject({ error: 'TERMINAL_PRIVATE' })
// After 3 minutes on the prompt, one alert, and no more while it still waits.
const alerts = async () => (await rows()).filter(m => m.source?.kind === 'terminal-alert')
diff --git a/docs/plans/2026-11-02-waiting-step-not-lost-plan.md b/docs/plans/2026-11-02-waiting-step-not-lost-plan.md
new file mode 100644
index 000000000..f0101c2d4
--- /dev/null
+++ b/docs/plans/2026-11-02-waiting-step-not-lost-plan.md
@@ -0,0 +1,57 @@
+# A Step Waiting For Its Engineer Is Not Lost Implementation Plan
+
+> **How this is worked:** by the project's instructions, task by task, each failing test committed before its code.
+
+**Goal:** A Review or Test step that has spoken to its task's Engineer stays with its agent while the Engineer fixes, and is moved as before once a newer head is ready and it stays quiet for 30 minutes.
+
+**Architecture:** `waitingForRevision` in `liveness.ts` already holds a step's quiet time, but only a failed `work.check` starts it, and Reviewers now give their verdict as a post. So a post from the step's agent to the Engineer records when it was made, if the Engineer was waiting on this review or the post asks for changes (`Ready to merge: No` or `With fixes`). It holds the step while the Engineer isn't waiting on a review, and the Engineer's next Ready ends it through `revisionReady`, which already restarts the quiet time.
+
+**Tech Stack:** TypeScript, Vitest, real Mongo for the integration suite.
+
+**Spec:** Task #2241 (Ken): project instructions revision 27 tell a Reviewer or Tester to stay Working while the Engineer fixes its findings; 35 lost attempts in a day came from the timer.
+
+## Global Constraints
+
+- The PR body starts with: `Requested by [email protected] through Harness.`
+- Swarm code stays out of `cli/src/core`. No env switch.
+- A stopped session, an offline machine, a usage limit and a failing model still lose the task at once.
+- Full Super Tab integration suite (`npm run test:super-tabs`) at the final head. Reviewer: Cleo.
+
+## Review Focus
+
+1. A step whose agent never wrote to the Engineer is moved as before.
+2. A post while the Engineer is waiting on a review holds nothing: "starting now" and then silence still moves. So does a verdict the Engineer doesn't pick up within 30 minutes.
+3. The Engineer's own posts and heartbeats start nothing (review of #2487).
+4. A note to an Engineer already working holds nothing, as `integration/superTabLiveness.test.ts` already pinned: "still reading", then silence, moves.
+5. The server reads one phrase of a post's text, the form the instructions set for a verdict. A Reviewer who words it differently while the Engineer is working is moved as before, which is the safe side.
+6. A named limit: a Reviewer that writes to an Engineer waiting on its review, then hangs with a live session, isn't moved once that Engineer goes back to working, until the next Ready, the Engineer's post to it, or the task's end. The PM's 30-minute read of open tasks still shows it.
+
+## Design
+
+- **Growth:** one number on an assignment, which goes with it.
+- **Concurrency:** written in the post's own command, on the group that command already locks.
+- **Read cost:** N/A because it reads nothing new; the check uses what's loaded.
+- **Scale:** N/A because it adds one comparison per active step in a sweep.
+- **Compatibility:** N/A because no client reads the field. An attempt from before this has none and behaves as before.
+- **Migration and rollback:** none. Rolling back leaves an unused field.
+- **Audience:** N/A because it's server-only and exposes nothing.
+- **Identity:** the post's actor must be the step's own assignee, as the server knows it.
+- **Failure:** the step shows as waiting on a revision, the state that already exists, so a hold is visible.
+- **Platforms:** N/A because this is server code.
+
+---
+
+### Task 1: A post to the Engineer holds the step
+
+**Files:**
+- Modify: `backend/src/superTabs/liveness.ts`, `backend/src/superTabs/model.ts`, `backend/src/superTabs/commands.ts`
+- Test: `backend/src/superTabs/liveness.test.ts`, `backend/src/superTabs/steps.test.ts`
+
+**Interfaces:**
+- Produces: `Assignment.toldEngineerAt?: number`; `toldEngineer(state, group, agentId, recipients, text, now): void`.
+
+- [ ] **Step 1: Write the failing tests:** through commands, a Reviewer's post to the Engineer with the Engineer working isn't lost past 30 minutes; the same step, after the Engineer's next Ready and 30 quiet minutes, is lost; a post while the Engineer waits on review holds nothing; a step that never wrote is lost; a post to someone else holds nothing; a note to a working Engineer holds nothing, and a verdict asking for changes does; the Engineer's own post holds nothing; a stopped session is still lost at once.
+- [ ] **Step 2: Run them:** `npm test -- src/superTabs/liveness.test.ts src/superTabs/steps.test.ts` in `backend`. Expected: the hold tests FAIL, and the moved-as-before tests pass on main.
+- [ ] **Step 3: Implement** `toldEngineer`, call it where a post renews its task, extend `waitingForRevision` and clear the field in `revisionReady`.
+- [ ] **Step 4: Run them.** Expected: PASS.
+- [ ] **Step 5: Commit, run `npm run test:super-tabs`, mark the pull request ready** and ask Cleo.