Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(server): settle no longer leaves monitors and dev servers running (#5774)
Theo Browne5bb8c0366447
diff --git a/apps/server/src/orchestration/decider.settled.test.ts b/apps/server/src/orchestration/decider.settled.test.tsindex 73f1cbf91..e05776468 100644--- a/apps/server/src/orchestration/decider.settled.test.ts+++ b/apps/server/src/orchestration/decider.settled.test.ts@@ -518,4 +518,55 @@ it.layer(NodeServices.layer)("settled thread decider", (it) => {expect(routineEvents.map((event) => event.type)).toEqual(["thread.activity-appended"]);}),);++ it.effect("drops an onlyIfSettled session stop when the thread was re-engaged", () =>+ Effect.gen(function* () {+ const stopCommand = (commandId: string) =>+ ({+ type: "thread.session.stop",+ commandId: CommandId.make(commandId),+ threadId: ThreadId.make("thread-1"),+ createdAt: NOW,+ onlyIfSettled: true,+ }) as const;++ // Still settled with an idle session: the cleanup stop goes through.+ const stopped = yield* decideOrchestrationCommand({+ command: stopCommand("cmd-stop-settled-idle"),+ readModel: makeReadModel("settled", null, makeSession("ready")),+ });+ const stoppedEvents = Array.isArray(stopped) ? stopped : [stopped];+ expect(stoppedEvents.map((event) => event.type)).toEqual(["thread.session-stop-requested"]);++ // Re-engaged before the stop was decided (a turn start unsettles the+ // thread): the stale cleanup stop must not kill the new session.+ const unsettledError = yield* decideOrchestrationCommand({+ command: stopCommand("cmd-stop-unsettled"),+ readModel: makeReadModel(null, null, makeSession("starting")),+ }).pipe(Effect.flip);+ expect(unsettledError._tag).toBe("OrchestrationCommandInvariantError");++ // Still settled but the session is already coming alive: same drop.+ const aliveError = yield* decideOrchestrationCommand({+ command: stopCommand("cmd-stop-session-alive"),+ readModel: makeReadModel("settled", null, makeSession("starting")),+ }).pipe(Effect.flip);+ expect(aliveError._tag).toBe("OrchestrationCommandInvariantError");++ // Without the flag the stop stays unconditional (archive, stop button).+ const unconditional = yield* decideOrchestrationCommand({+ command: {+ type: "thread.session.stop",+ commandId: CommandId.make("cmd-stop-unconditional"),+ threadId: ThreadId.make("thread-1"),+ createdAt: NOW,+ },+ readModel: makeReadModel(null, null, makeSession("starting")),+ });+ const unconditionalEvents = Array.isArray(unconditional) ? unconditional : [unconditional];+ expect(unconditionalEvents.map((event) => event.type)).toEqual([+ "thread.session-stop-requested",+ ]);+ }),+ );});diff --git a/apps/server/src/orchestration/decider.ts b/apps/server/src/orchestration/decider.tsindex 3de2592c8..6e87b5bd5 100644--- a/apps/server/src/orchestration/decider.ts+++ b/apps/server/src/orchestration/decider.ts@@ -1116,11 +1116,32 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"}case "thread.session.stop": {- yield* requireThread({+ const thread = yield* requireThread({readModel,command,threadId: command.threadId,});+ // Settle-cleanup stops are conditional: between the settle landing and+ // this command, another client may have re-engaged the thread (a turn+ // start unsettles it and brings the session alive). Commands are+ // decided serially against this read model, so checking here — not in+ // the dispatcher's pre-settle snapshot — closes that race.+ if (command.onlyIfSettled === true) {+ const sessionComingAlive =+ thread.session?.status === "starting" || thread.session?.status === "running";+ if (+ thread.settledOverride !== "settled" ||+ sessionComingAlive ||+ threadHasQueuedTurnStart(thread, command.createdAt)+ ) {+ return yield* Effect.fail(+ new OrchestrationCommandInvariantError({+ commandType: command.type,+ detail: `thread ${command.threadId} was re-engaged after settle; skipping session stop`,+ }),+ );+ }+ }return {...(yield* withEventBase({aggregateKind: "thread",diff --git a/apps/server/src/server.test.ts b/apps/server/src/server.test.tsindex d982c2e19..cb64c6a48 100644--- a/apps/server/src/server.test.ts+++ b/apps/server/src/server.test.ts@@ -7020,6 +7020,126 @@ it.layer(NodeServices.layer)("server router seam", (it) => {}).pipe(Effect.provide(NodeHttpServer.layerTest)),);+ it.effect("stops the provider session after settle without closing terminals", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("thread-settle");+ const effects: string[] = [];+ const dispatchedCommands: Array<OrchestrationCommand> = [];+ const now = "2026-01-01T00:00:00.000Z";++ yield* buildAppUnderTest({+ layers: {+ terminalManager: {+ close: (input) =>+ Effect.sync(() => {+ effects.push(`terminal.close:${input.threadId}`);+ }),+ },+ orchestrationEngine: {+ dispatch: (command) =>+ Effect.sync(() => {+ dispatchedCommands.push(command);+ effects.push(`dispatch:${command.type}`);+ return { sequence: dispatchedCommands.length };+ }),+ },+ projectionSnapshotQuery: {+ getThreadShellById: () =>+ Effect.succeed(+ Option.some(+ makeDefaultOrchestrationThreadShell({+ id: threadId,+ updatedAt: now,+ session: {+ threadId,+ status: "ready",+ providerName: "claudeAgent",+ runtimeMode: "full-access",+ activeTurnId: null,+ lastError: null,+ updatedAt: now,+ },+ }),+ ),+ ),+ },+ },+ });++ const wsUrl = yield* getWsServerUrl("/ws");+ const dispatchResult = yield* Effect.scoped(+ withWsRpcClient(wsUrl, (client) =>+ client[ORCHESTRATION_WS_METHODS.dispatchCommand]({+ type: "thread.settle",+ commandId: CommandId.make("cmd-thread-settle"),+ threadId,+ }),+ ),+ );++ assert.equal(dispatchResult.sequence, 1);+ assert.deepEqual(effects, ["dispatch:thread.settle", "dispatch:thread.session.stop"]);+ const sessionStopCommand = dispatchedCommands[1];+ assert.equal(sessionStopCommand?.type, "thread.session.stop");+ if (sessionStopCommand?.type === "thread.session.stop") {+ assert.equal(sessionStopCommand.threadId, threadId);+ assert.equal(sessionStopCommand.commandId, "session-stop-for-settle:cmd-thread-settle");+ assert.equal(sessionStopCommand.onlyIfSettled, true);+ }+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),+ );++ it.effect("settles without dispatching session stop when the thread has no session", () =>+ Effect.gen(function* () {+ const threadId = ThreadId.make("thread-settle-no-session");+ const effects: string[] = [];+ const dispatchedCommands: Array<OrchestrationCommand> = [];++ yield* buildAppUnderTest({+ layers: {+ terminalManager: {+ close: (input) =>+ Effect.sync(() => {+ effects.push(`terminal.close:${input.threadId}`);+ }),+ },+ orchestrationEngine: {+ dispatch: (command) =>+ Effect.sync(() => {+ dispatchedCommands.push(command);+ effects.push(`dispatch:${command.type}`);+ return { sequence: dispatchedCommands.length };+ }),+ },+ projectionSnapshotQuery: {+ getThreadShellById: () =>+ Effect.succeed(+ Option.some(makeDefaultOrchestrationThreadShell({ id: threadId, session: null })),+ ),+ },+ },+ });++ const wsUrl = yield* getWsServerUrl("/ws");+ const dispatchResult = yield* Effect.scoped(+ withWsRpcClient(wsUrl, (client) =>+ client[ORCHESTRATION_WS_METHODS.dispatchCommand]({+ type: "thread.settle",+ commandId: CommandId.make("cmd-thread-settle-no-session"),+ threadId,+ }),+ ),+ );++ assert.equal(dispatchResult.sequence, 1);+ assert.deepEqual(effects, ["dispatch:thread.settle"]);+ assert.deepEqual(+ dispatchedCommands.map((command) => command.type),+ ["thread.settle"],+ );+ }).pipe(Effect.provide(NodeHttpServer.layerTest)),+ );+it.effect("archives and still closes terminals when session stop fails", () =>Effect.gen(function* () {const threadId = ThreadId.make("thread-archive-stop-failure");diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.tsindex 6d518fe16..789f39b63 100644--- a/apps/server/src/ws.ts+++ b/apps/server/src/ws.ts@@ -1036,53 +1036,83 @@ const makeWsRpcLayer = (ORCHESTRATION_WS_METHODS.dispatchCommand,Effect.gen(function* () {const normalizedCommand = yield* normalizeDispatchCommand(command);- const shouldStopSessionAfterArchive =- normalizedCommand.type === "thread.archive"- ? yield* projectionSnapshotQuery- .getThreadShellById(normalizedCommand.threadId)- .pipe(- Effect.map(- Option.match({- onNone: () => false,- onSome: (thread) =>- thread.session !== null && thread.session.status !== "stopped",- }),- ),- Effect.orElseSucceed(() => false),- )- : false;+ // Archive and settle both mean "done with this thread", so a+ // live provider session must not keep running background work+ // (PR monitors, dev servers, subagent fleets) after either+ // lands. The decider rejects settling a starting/running+ // session, so for settle this only ever stops an idle one; a+ // stopped session-set does not count as activity, so the stop+ // cannot un-settle the thread it follows.+ const parkingCommand =+ normalizedCommand.type === "thread.archive" ||+ normalizedCommand.type === "thread.settle"+ ? normalizedCommand+ : undefined;+ // Best-effort on purpose: the user's archive/settle must not+ // fail because this cleanup read blipped, so a failed read+ // logs and skips the stop instead of propagating.+ const shouldStopSessionAfterCommand = parkingCommand+ ? yield* projectionSnapshotQuery.getThreadShellById(parkingCommand.threadId).pipe(+ Effect.map(+ Option.match({+ onNone: () => false,+ onSome: (thread) =>+ thread.session !== null && thread.session.status !== "stopped",+ }),+ ),+ Effect.catchCause((cause) =>+ Effect.logWarning(+ "failed to read thread session state before session-stop check",+ { threadId: parkingCommand.threadId, cause },+ ).pipe(Effect.as(false)),+ ),+ )+ : false;const result = yield* dispatchNormalizedCommand(normalizedCommand);- if (normalizedCommand.type === "thread.archive") {- if (shouldStopSessionAfterArchive) {+ if (parkingCommand) {+ const parkingKind = parkingCommand.type === "thread.archive" ? "archive" : "settle";+ if (shouldStopSessionAfterCommand) {yield* Effect.gen(function* () {const stopCommand = yield* normalizeDispatchCommand({type: "thread.session.stop",commandId: CommandId.make(- `session-stop-for-archive:${normalizedCommand.commandId}`,+ `session-stop-for-${parkingKind}:${parkingCommand.commandId}`,),- threadId: normalizedCommand.threadId,+ threadId: parkingCommand.threadId,createdAt: yield* nowIso,+ // A settled thread can be re-engaged before this stop is+ // decided; the decider then drops the stop instead of+ // killing the new session. Archive stops stay+ // unconditional: turn starts on archived threads are+ // rejected, so there is no new session to protect.+ ...(parkingKind === "settle" ? { onlyIfSettled: true } : {}),});yield* dispatchNormalizedCommand(stopCommand);}).pipe(Effect.catchCause((cause) =>- Effect.logWarning("failed to stop provider session during archive", {- threadId: normalizedCommand.threadId,+ Effect.logWarning(`failed to stop provider session during ${parkingKind}`, {+ threadId: parkingCommand.threadId,cause,}),),);}- yield* terminalManager.close({ threadId: normalizedCommand.threadId }).pipe(- Effect.catch((error) =>- Effect.logWarning("failed to close thread terminals after archive", {- threadId: normalizedCommand.threadId,- error: error.message,- }),- ),- );+ // Terminals are user-opened panes, not thread background+ // work: archive removes the thread from view so they close+ // with it, but a settled thread stays reachable and may be+ // un-settled, so its terminals stay up.+ if (parkingCommand.type === "thread.archive") {+ yield* terminalManager.close({ threadId: parkingCommand.threadId }).pipe(+ Effect.catch((error) =>+ Effect.logWarning("failed to close thread terminals after archive", {+ threadId: parkingCommand.threadId,+ error: error.message,+ }),+ ),+ );+ }}return result;}).pipe(diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.tsindex 87270d98c..96d20c0a3 100644--- a/packages/contracts/src/orchestration.ts+++ b/packages/contracts/src/orchestration.ts@@ -870,6 +870,12 @@ const ThreadSessionStopCommand = Schema.Struct({commandId: CommandId,threadId: ThreadId,createdAt: IsoDateTime,+ // Settle-cleanup stops are conditional: the decider drops the stop if the+ // thread was re-engaged (unsettled, session starting/running, or a queued+ // turn start) between the settle and this command. Guarding in the decider+ // closes the race a post-settle snapshot read cannot: commands are decided+ // serially against the authoritative read model.+ onlyIfSettled: Schema.optional(Schema.Boolean),});const DispatchableClientOrchestrationCommand = Schema.Union([