fix(t3x): auto-resume never fired — 'thread-advanced' false cancellation on settled turns

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }

apps/server/src/t3x/autoResume/Reactor.test.ts

@@ -34,6 +34,9 @@ const readModel = (o: {
  messages?: Array<{ id: string; role: string }>;
  status?: string;
  latestTurnId?: string;
+ /** Explicit latestTurn override; pass null to model an idle thread whose
+ * projection row has no latest_turn_id (see radroid/t3code#6). */
+ latestTurn?: { turnId: string; state: string } | null;
 }): OrchestrationReadModel =>
  ({
  snapshotSequence: 1,
@@ -51,7 +54,10 @@ const readModel = (o: {
  settledOverride: null,
  messages: o.messages ?? [{ id: "u1", role: "user" }],
  activities: [],
- latestTurn: { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
+ latestTurn:
+ o.latestTurn !== undefined
+ ? o.latestTurn
+ : { turnId: o.latestTurnId ?? "turn-1", state: "completed" },
  session: { status: o.status ?? "ready", providerName: "claudeAgent" },
  },
  ],
@@ -201,6 +207,40 @@ describe("AutoResumeReactor (integration)", () => {
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
  );
 
+ // Regression for radroid/t3code#6 — the incident shape observed in production:
+ // the limit lands while the turn is RUNNING (baseline captures its id); by wake
+ // time the turn has settled and the projection row has no latest_turn_id, so the
+ // snapshot reports latestTurn: null. That must NOT read as "thread-advanced".
+ it.effect("resumes when the limited turn has settled away by wake time (latestTurn null)", () =>
+ Effect.gen(function* () {
+ const { dispatched, modelRef, deps } = yield* harness(
+ readModel({ status: "running", latestTurn: { turnId: "turn-1", state: "running" } }),
+ [rejectedEvent(100)],
+ );
+
+ yield* Effect.gen(function* () {
+ yield* settle; // detection schedules; baseline.latestTurnId === "turn-1"
+
+ // The limited turn settles and the session stops during the wait — the
+ // projection's latest_turn_id empties out, so the snapshot's latestTurn is null.
+ yield* Ref.set(modelRef, readModel({ status: "stopped", latestTurn: null }));
+
+ yield* advancePastResume;
+
+ const commands = yield* Ref.get(dispatched);
+ const turnStarts = commands.filter((c) => c.type === "thread.turn.start");
+ assert.strictEqual(turnStarts.length, 1, "the settled thread must resume, not cancel");
+ const summaries = commands
+ .filter((c) => c.type === "thread.activity.append")
+ .map((c) => (c as unknown as { activity: { summary: string } }).activity.summary);
+ assert.isFalse(
+ summaries.some((s) => s.includes("thread-advanced")),
+ "no thread-advanced cancellation may be posted",
+ );
+ }).pipe(Effect.provide(AutoResumeReactorLive.pipe(Layer.provideMerge(deps))));
+ }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, TestClock.layer()))),
+ );
+
  it.effect("does NOT resume when the user takes over before the window reopens", () =>
  Effect.gen(function* () {
  const { dispatched, modelRef, deps } = yield* harness(readModel({}), [rejectedEvent(100)]);

apps/server/src/t3x/autoResume/guards.test.ts

@@ -166,6 +166,25 @@ describe("cancelReason", () => {
  expect(cancelReason(thread, baseline())).toBe("thread-advanced");
  });
 
+ // Regression for radroid/t3code#6: the projection populates latest_turn_id only while
+ // a turn is active, so a limit captured mid-turn (baseline has the running turn's id)
+ // always sees latestTurn: null once that turn settles. Null is "no active turn", not
+ // advancement — cancelling here killed every real-world resume.
+ it("does NOT treat a settled-away turn (latestTurn null at fire) as advancement", () => {
+ const thread = makeThread({
+ messages: [{ id: "u1", role: "user" }],
+ status: "stopped",
+ });
+ expect(thread.latestTurn).toBeNull();
+ expect(cancelReason(thread, baseline())).toBeNull();
+ });
+
+ it("still detects advancement when a turn exists but the baseline had none", () => {
+ const noTurnBaseline = captureBaseline(makeThread({ messages: [{ id: "u1", role: "user" }] }));
+ const thread = makeThread({ messages: [{ id: "u1", role: "user" }], latestTurnId: "turn-9" });
+ expect(cancelReason(thread, noTurnBaseline)).toBe("thread-advanced");
+ });
+
  it("blocks when awaiting input", () => {
  const thread = makeThread({
  messages: [{ id: "u1", role: "user" }],

apps/server/src/t3x/autoResume/guards.ts

@@ -130,6 +130,17 @@ export function cancelReason(
  if (threadIsProgressing(thread)) return "progressing";
  if (hasOpenBlockingRequest(thread.activities)) return "awaiting-input";
  if (newestUserMessageId(thread) !== baseline.newestUserMessageId) return "user-took-over";
- if ((thread.latestTurn?.turnId ?? null) !== baseline.latestTurnId) return "thread-advanced";
+ // Advancement needs POSITIVE evidence: a different, non-null turn id. The snapshot's
+ // `latestTurn` is joined on `projection_threads.latest_turn_id`, which is populated
+ // only while a turn is active — so a usage limit that lands mid-turn captures the
+ // running turn's id in the baseline, and by fire time (turn settled, session idle)
+ // the snapshot reports `latestTurn: null`. That null means "no active turn", not
+ // "the thread moved on"; treating it as advancement cancelled every real resume
+ // (radroid/t3code#6). A genuine user takeover is caught above via the newest user
+ // message; active work is caught by `progressing`.
+ const currentTurnId = thread.latestTurn?.turnId ?? null;
+ if (currentTurnId !== null && currentTurnId !== baseline.latestTurnId) {
+ return "thread-advanced";
+ }
  return null;
 }