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.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
Merge batch 11-03 bb: #2666 #2659 (#2667)
0xken154e0369455271
diff --git a/backend/src/superTabs/commands.ts b/backend/src/superTabs/commands.tsindex 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.tsindex 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.tsindex 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!.toldEngineerAtrestartQuietTime(linked.assignment!, now)recordTaskState(state, linked, now)}diff --git a/backend/src/superTabs/model.ts b/backend/src/superTabs/model.tsindex 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?: numberdiff --git a/backend/src/superTabs/parts/light.test.ts b/backend/src/superTabs/parts/light.test.tsindex 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.tsindex 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 constconst LIGHT_GROUP = {diff --git a/backend/src/superTabs/steps.test.ts b/backend/src/superTabs/steps.test.tsindex 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.tsindex 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.mdnew file mode 100644index 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.