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.
C015 & C016
Julius Marminge76208f79de4c
diff --git a/.plans/16c-pr89-remediation-checklist.md b/.plans/16c-pr89-remediation-checklist.mdindex ba7686dfd..8d30b2dd4 100644--- a/.plans/16c-pr89-remediation-checklist.md+++ b/.plans/16c-pr89-remediation-checklist.md@@ -11,7 +11,7 @@ Status values:- `DONE`: Implemented and verified- `CLOSED_INVALID`: Stale/invalid review finding-Counts: active `52` (`valid=33`, `partially-valid=19`), closed-invalid `5`+Counts: active `51` (`valid=33`, `partially-valid=18`), closed-invalid `6`## Active Checklist@@ -172,17 +172,8 @@ Counts: active `52` (`valid=33`, `partially-valid=19`), closed-invalid `5`- Threads: PRRT_kwDORLtfbc5whtrM- Audit note: Persisted event can outpace in-memory projection on mid-flight failure.-- [ ] `C014` Engine error handler catches all errors including non-invariant ones- - Status: `TODO`- - Verdict: `partially-valid`- - Severity: `Medium`- - Area: `Event ordering and state consistency`- - File: `apps/server/src/orchestration/Layers/OrchestrationEngine.ts:144`- - Threads: PRRT_kwDORLtfbc5wkPaJ- - Audit note: Broad catch may be intentional for liveness; correctness concern is contextual.--- [ ] `C015` The gap-filling fallback logic can retain messages from turns that are about to be deleted, causing foreign key violations. Consider removing the fallback logic entirely, or filtering `fallbackUserMessages` and `fallbackAssistantMessages` to only include messages whose `turnId` is in `retainedTurnIds`. <details> <summary>π Reply "<strong>fix it for me</strong>" or copy this <strong>AI Prompt</strong> for your agent:</summary>- - Status: `TODO`+- [x] `C015` The gap-filling fallback logic can retain messages from turns that are about to be deleted, causing foreign key violations. Consider removing the fallback logic entirely, or filtering `fallbackUserMessages` and `fallbackAssistantMessages` to only include messages whose `turnId` is in `retainedTurnIds`. <details> <summary>π Reply "<strong>fix it for me</strong>" or copy this <strong>AI Prompt</strong> for your agent:</summary>+ - Status: `DONE`- Verdict: `partially-valid`- Severity: `Medium`- Area: `Event ordering and state consistency`@@ -190,8 +181,8 @@ Counts: active `52` (`valid=33`, `partially-valid=19`), closed-invalid `5`- Threads: PRRT_kwDORLtfbc5whxJO- Audit note: Message fallback retention issue is real, but prior FK-violation claim is overstated.-- [ ] `C016` The in-memory `pendingTurnStartByThreadId` map isn't restored during bootstrap. If the service restarts after processing `thread.turn-start-requested` but before `thread.session-set`, the `userMessageId` and `startedAt` will be lost since bootstrap resumes *after* the committed sequence. Consider persisting this pending state or processing these two events atomically. <details> <summary>π Reply "<strong>fix it for me</strong>" or copy this <strong>AI Prompt</strong> for your agent:</summary>- - Status: `TODO`+- [x] `C016` The in-memory `pendingTurnStartByThreadId` map isn't restored during bootstrap. If the service restarts after processing `thread.turn-start-requested` but before `thread.session-set`, the `userMessageId` and `startedAt` will be lost since bootstrap resumes *after* the committed sequence. Consider persisting this pending state or processing these two events atomically. <details> <summary>π Reply "<strong>fix it for me</strong>" or copy this <strong>AI Prompt</strong> for your agent:</summary>+ - Status: `DONE`- Verdict: `valid`- Severity: `Medium`- Area: `Event ordering and state consistency`@@ -506,6 +497,13 @@ Counts: active `52` (`valid=33`, `partially-valid=19`), closed-invalid `5`## Closed Invalid Items+- [x] `C014` Engine error handler catches all errors including non-invariant ones+ - Status: `CLOSED_INVALID`+ - Severity: `Medium`+ - File: `apps/server/src/orchestration/Layers/OrchestrationEngine.ts:144`+ - Threads: PRRT_kwDORLtfbc5wkPaJ+ - Rationale: Broad catch is intentional for worker liveness; transactional dispatch path prevents the claimed non-invariant idempotency break in current design.+- [x] `C021` Shared mutable default metadata object causes stale eventId- Status: `CLOSED_INVALID`- Severity: `Medium`diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.test.tsindex ce775b32f..a08210060 100644--- a/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts+++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts@@ -1,18 +1,29 @@import {+ CheckpointRef,CommandId,CorrelationId,EventId,MessageId,+ ProviderSessionId,+ ProviderThreadId,ProjectId,ThreadId,+ TurnId,} from "@t3tools/contracts";+import { NodeServices } from "@effect/platform-node";import { assert, it } from "@effect/vitest";import { Effect, Layer } from "effect";+import fs from "node:fs";+import os from "node:os";+import path from "node:path";import * as SqlClient from "effect/unstable/sql/SqlClient";import { OrchestrationCommandReceiptRepositoryLive } from "../../persistence/Layers/OrchestrationCommandReceipts.ts";import { OrchestrationEventStoreLive } from "../../persistence/Layers/OrchestrationEventStore.ts";-import { SqlitePersistenceMemory } from "../../persistence/Layers/Sqlite.ts";+import {+ makeSqlitePersistenceLive,+ SqlitePersistenceMemory,+} from "../../persistence/Layers/Sqlite.ts";import { OrchestrationEventStore } from "../../persistence/Services/OrchestrationEventStore.ts";import { OrchestrationEngineLive } from "./OrchestrationEngine.ts";import {@@ -400,8 +411,323 @@ projectionLayer("OrchestrationProjectionPipeline", (it) => {assert.isFalse(Boolean(messageRows[0]?.isStreaming));}),);++ it.effect("does not fallback-retain messages whose turnId is removed by revert", () =>+ Effect.gen(function* () {+ const projectionPipeline = yield* OrchestrationProjectionPipeline;+ const eventStore = yield* OrchestrationEventStore;+ const sql = yield* SqlClient.SqlClient;+ const appendAndProject = (event: Parameters<typeof eventStore.append>[0]) =>+ eventStore+ .append(event)+ .pipe(Effect.flatMap((savedEvent) => projectionPipeline.projectEvent(savedEvent)));++ yield* appendAndProject({+ type: "project.created",+ eventId: EventId.makeUnsafe("evt-revert-1"),+ aggregateKind: "project",+ aggregateId: ProjectId.makeUnsafe("project-revert"),+ occurredAt: "2026-02-26T12:00:00.000Z",+ commandId: CommandId.makeUnsafe("cmd-revert-1"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-1"),+ metadata: {},+ payload: {+ projectId: ProjectId.makeUnsafe("project-revert"),+ title: "Project Revert",+ workspaceRoot: "/tmp/project-revert",+ defaultModel: null,+ scripts: [],+ createdAt: "2026-02-26T12:00:00.000Z",+ updatedAt: "2026-02-26T12:00:00.000Z",+ },+ });++ yield* appendAndProject({+ type: "thread.created",+ eventId: EventId.makeUnsafe("evt-revert-2"),+ aggregateKind: "thread",+ aggregateId: ThreadId.makeUnsafe("thread-revert"),+ occurredAt: "2026-02-26T12:00:01.000Z",+ commandId: CommandId.makeUnsafe("cmd-revert-2"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-2"),+ metadata: {},+ payload: {+ threadId: ThreadId.makeUnsafe("thread-revert"),+ projectId: ProjectId.makeUnsafe("project-revert"),+ title: "Thread Revert",+ model: "gpt-5-codex",+ branch: null,+ worktreePath: null,+ createdAt: "2026-02-26T12:00:01.000Z",+ updatedAt: "2026-02-26T12:00:01.000Z",+ },+ });++ yield* appendAndProject({+ type: "thread.turn-diff-completed",+ eventId: EventId.makeUnsafe("evt-revert-3"),+ aggregateKind: "thread",+ aggregateId: ThreadId.makeUnsafe("thread-revert"),+ occurredAt: "2026-02-26T12:00:02.000Z",+ commandId: CommandId.makeUnsafe("cmd-revert-3"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-3"),+ metadata: {},+ payload: {+ threadId: ThreadId.makeUnsafe("thread-revert"),+ turnId: TurnId.makeUnsafe("turn-1"),+ checkpointTurnCount: 1,+ checkpointRef: CheckpointRef.makeUnsafe("refs/t3/checkpoints/thread-revert/turn/1"),+ status: "ready",+ files: [],+ assistantMessageId: MessageId.makeUnsafe("assistant-keep"),+ completedAt: "2026-02-26T12:00:02.000Z",+ },+ });++ yield* appendAndProject({+ type: "thread.message-sent",+ eventId: EventId.makeUnsafe("evt-revert-4"),+ aggregateKind: "thread",+ aggregateId: ThreadId.makeUnsafe("thread-revert"),+ occurredAt: "2026-02-26T12:00:02.100Z",+ commandId: CommandId.makeUnsafe("cmd-revert-4"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-4"),+ metadata: {},+ payload: {+ threadId: ThreadId.makeUnsafe("thread-revert"),+ messageId: MessageId.makeUnsafe("assistant-keep"),+ role: "assistant",+ text: "kept",+ turnId: TurnId.makeUnsafe("turn-1"),+ streaming: false,+ createdAt: "2026-02-26T12:00:02.100Z",+ updatedAt: "2026-02-26T12:00:02.100Z",+ },+ });++ yield* appendAndProject({+ type: "thread.turn-diff-completed",+ eventId: EventId.makeUnsafe("evt-revert-5"),+ aggregateKind: "thread",+ aggregateId: ThreadId.makeUnsafe("thread-revert"),+ occurredAt: "2026-02-26T12:00:03.000Z",+ commandId: CommandId.makeUnsafe("cmd-revert-5"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-5"),+ metadata: {},+ payload: {+ threadId: ThreadId.makeUnsafe("thread-revert"),+ turnId: TurnId.makeUnsafe("turn-2"),+ checkpointTurnCount: 2,+ checkpointRef: CheckpointRef.makeUnsafe("refs/t3/checkpoints/thread-revert/turn/2"),+ status: "ready",+ files: [],+ assistantMessageId: MessageId.makeUnsafe("assistant-remove"),+ completedAt: "2026-02-26T12:00:03.000Z",+ },+ });++ yield* appendAndProject({+ type: "thread.message-sent",+ eventId: EventId.makeUnsafe("evt-revert-6"),+ aggregateKind: "thread",+ aggregateId: ThreadId.makeUnsafe("thread-revert"),+ occurredAt: "2026-02-26T12:00:03.050Z",+ commandId: CommandId.makeUnsafe("cmd-revert-6"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-6"),+ metadata: {},+ payload: {+ threadId: ThreadId.makeUnsafe("thread-revert"),+ messageId: MessageId.makeUnsafe("user-remove"),+ role: "user",+ text: "removed",+ turnId: TurnId.makeUnsafe("turn-2"),+ streaming: false,+ createdAt: "2026-02-26T12:00:03.050Z",+ updatedAt: "2026-02-26T12:00:03.050Z",+ },+ });++ yield* appendAndProject({+ type: "thread.message-sent",+ eventId: EventId.makeUnsafe("evt-revert-7"),+ aggregateKind: "thread",+ aggregateId: ThreadId.makeUnsafe("thread-revert"),+ occurredAt: "2026-02-26T12:00:03.100Z",+ commandId: CommandId.makeUnsafe("cmd-revert-7"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-7"),+ metadata: {},+ payload: {+ threadId: ThreadId.makeUnsafe("thread-revert"),+ messageId: MessageId.makeUnsafe("assistant-remove"),+ role: "assistant",+ text: "removed",+ turnId: TurnId.makeUnsafe("turn-2"),+ streaming: false,+ createdAt: "2026-02-26T12:00:03.100Z",+ updatedAt: "2026-02-26T12:00:03.100Z",+ },+ });++ yield* appendAndProject({+ type: "thread.reverted",+ eventId: EventId.makeUnsafe("evt-revert-8"),+ aggregateKind: "thread",+ aggregateId: ThreadId.makeUnsafe("thread-revert"),+ occurredAt: "2026-02-26T12:00:04.000Z",+ commandId: CommandId.makeUnsafe("cmd-revert-8"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-revert-8"),+ metadata: {},+ payload: {+ threadId: ThreadId.makeUnsafe("thread-revert"),+ turnCount: 1,+ },+ });++ const messageRows = yield* sql<{+ readonly messageId: string;+ readonly turnId: string | null;+ readonly role: string;+ }>`+ SELECT+ message_id AS "messageId",+ turn_id AS "turnId",+ role+ FROM projection_thread_messages+ WHERE thread_id = 'thread-revert'+ ORDER BY created_at ASC, message_id ASC+ `;+ assert.deepEqual(messageRows, [+ {+ messageId: "assistant-keep",+ turnId: "turn-1",+ role: "assistant",+ },+ ]);+ }),+ );+});+it.effect("restores pending turn-start metadata across projection pipeline restart", () =>+ Effect.gen(function* () {+ const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "t3-projection-pipeline-restart-"));+ const dbPath = path.join(tempDir, "orchestration.sqlite");+ const persistenceLayer = makeSqlitePersistenceLive(dbPath);+ const firstProjectionLayer = OrchestrationProjectionPipelineLive.pipe(+ Layer.provideMerge(OrchestrationEventStoreLive),+ Layer.provideMerge(persistenceLayer),+ );+ const secondProjectionLayer = OrchestrationProjectionPipelineLive.pipe(+ Layer.provideMerge(OrchestrationEventStoreLive),+ Layer.provideMerge(persistenceLayer),+ );++ const threadId = ThreadId.makeUnsafe("thread-restart");+ const turnId = TurnId.makeUnsafe("turn-restart");+ const messageId = MessageId.makeUnsafe("message-restart");+ const turnStartedAt = "2026-02-26T14:00:00.000Z";+ const sessionSetAt = "2026-02-26T14:00:05.000Z";++ yield* Effect.gen(function* () {+ const eventStore = yield* OrchestrationEventStore;+ const projectionPipeline = yield* OrchestrationProjectionPipeline;++ yield* eventStore.append({+ type: "thread.turn-start-requested",+ eventId: EventId.makeUnsafe("evt-restart-1"),+ aggregateKind: "thread",+ aggregateId: threadId,+ occurredAt: turnStartedAt,+ commandId: CommandId.makeUnsafe("cmd-restart-1"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-restart-1"),+ metadata: {},+ payload: {+ threadId,+ messageId,+ createdAt: turnStartedAt,+ },+ });++ yield* projectionPipeline.bootstrap;+ }).pipe(Effect.provide(firstProjectionLayer));++ const turnRows = yield* Effect.gen(function* () {+ const eventStore = yield* OrchestrationEventStore;+ const projectionPipeline = yield* OrchestrationProjectionPipeline;+ const sql = yield* SqlClient.SqlClient;++ yield* eventStore.append({+ type: "thread.session-set",+ eventId: EventId.makeUnsafe("evt-restart-2"),+ aggregateKind: "thread",+ aggregateId: threadId,+ occurredAt: sessionSetAt,+ commandId: CommandId.makeUnsafe("cmd-restart-2"),+ causationEventId: null,+ correlationId: CorrelationId.makeUnsafe("cmd-restart-2"),+ metadata: {+ providerSessionId: ProviderSessionId.makeUnsafe("provider-session-restart"),+ providerThreadId: ProviderThreadId.makeUnsafe("provider-thread-restart"),+ },+ payload: {+ threadId,+ session: {+ threadId,+ status: "running",+ providerName: "codex",+ providerSessionId: ProviderSessionId.makeUnsafe("provider-session-restart"),+ providerThreadId: ProviderThreadId.makeUnsafe("provider-thread-restart"),+ activeTurnId: turnId,+ lastError: null,+ updatedAt: sessionSetAt,+ },+ },+ });++ yield* projectionPipeline.bootstrap;++ const pendingRows = yield* sql<{ readonly threadId: string }>`+ SELECT thread_id AS "threadId"+ FROM projection_pending_turn_starts+ WHERE thread_id = ${threadId}+ `;+ assert.deepEqual(pendingRows, []);++ return yield* sql<{+ readonly turnId: string;+ readonly userMessageId: string | null;+ readonly startedAt: string;+ }>`+ SELECT+ turn_id AS "turnId",+ user_message_id AS "userMessageId",+ started_at AS "startedAt"+ FROM projection_thread_turns+ WHERE turn_id = ${turnId}+ `;+ }).pipe(Effect.provide(secondProjectionLayer));++ assert.deepEqual(turnRows, [+ {+ turnId: "turn-restart",+ userMessageId: "message-restart",+ startedAt: turnStartedAt,+ },+ ]);++ fs.rmSync(tempDir, { recursive: true, force: true });+ }).pipe(Effect.provide(NodeServices.layer)),+);+const engineLayer = it.layer(OrchestrationEngineLive.pipe(Layer.provide(OrchestrationProjectionPipelineLive),diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.tsindex b890adfba..81d0eb95d 100644--- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts+++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts@@ -6,6 +6,7 @@ import { toPersistenceSqlError, type ProjectionRepositoryError } from "../../perimport { OrchestrationEventStore } from "../../persistence/Services/OrchestrationEventStore.ts";import { ProjectionCheckpointRepository } from "../../persistence/Services/ProjectionCheckpoints.ts";import { ProjectionPendingApprovalRepository } from "../../persistence/Services/ProjectionPendingApprovals.ts";+import { ProjectionPendingTurnStartRepository } from "../../persistence/Services/ProjectionPendingTurnStarts.ts";import { ProjectionProjectRepository } from "../../persistence/Services/ProjectionProjects.ts";import { ProjectionStateRepository } from "../../persistence/Services/ProjectionState.ts";import { ProjectionThreadActivityRepository } from "../../persistence/Services/ProjectionThreadActivities.ts";@@ -20,6 +21,7 @@ import { ProjectionThreadTurnRepository } from "../../persistence/Services/Projeimport { ProjectionThreadRepository } from "../../persistence/Services/ProjectionThreads.ts";import { ProjectionCheckpointRepositoryLive } from "../../persistence/Layers/ProjectionCheckpoints.ts";import { ProjectionPendingApprovalRepositoryLive } from "../../persistence/Layers/ProjectionPendingApprovals.ts";+import { ProjectionPendingTurnStartRepositoryLive } from "../../persistence/Layers/ProjectionPendingTurnStarts.ts";import { ProjectionProjectRepositoryLive } from "../../persistence/Layers/ProjectionProjects.ts";import { ProjectionStateRepositoryLive } from "../../persistence/Layers/ProjectionState.ts";import { ProjectionThreadActivityRepositoryLive } from "../../persistence/Layers/ProjectionThreadActivities.ts";@@ -97,7 +99,12 @@ function retainProjectionMessagesAfterRevert(const missingUserCount = Math.max(0, turnCount - retainedUserCount);if (missingUserCount > 0) {const fallbackUserMessages = messages- .filter((message) => message.role === "user" && !retainedMessageIds.has(message.messageId))+ .filter(+ (message) =>+ message.role === "user" &&+ !retainedMessageIds.has(message.messageId) &&+ (message.turnId === null || retainedTurnIds.has(message.turnId)),+ ).toSorted((left, right) =>left.createdAt.localeCompare(right.createdAt) ||@@ -116,7 +123,10 @@ function retainProjectionMessagesAfterRevert(if (missingAssistantCount > 0) {const fallbackAssistantMessages = messages.filter(- (message) => message.role === "assistant" && !retainedMessageIds.has(message.messageId),+ (message) =>+ message.role === "assistant" &&+ !retainedMessageIds.has(message.messageId) &&+ (message.turnId === null || retainedTurnIds.has(message.turnId)),).toSorted((left, right) =>@@ -157,13 +167,7 @@ const makeOrchestrationProjectionPipeline = Effect.gen(function* () {const projectionThreadTurnRepository = yield* ProjectionThreadTurnRepository;const projectionCheckpointRepository = yield* ProjectionCheckpointRepository;const projectionPendingApprovalRepository = yield* ProjectionPendingApprovalRepository;- const pendingTurnStartByThreadId = new Map<- string,- {- readonly messageId: NonNullable<ProjectionThreadTurn["userMessageId"]>;- readonly createdAt: string;- }- >();+ const projectionPendingTurnStartRepository = yield* ProjectionPendingTurnStartRepository;const applyProjectsProjection: ProjectorDefinition["apply"] = (event) =>Effect.gen(function* () {@@ -473,7 +477,8 @@ const makeOrchestrationProjectionPipeline = Effect.gen(function* () {Effect.gen(function* () {switch (event.type) {case "thread.turn-start-requested": {- pendingTurnStartByThreadId.set(event.payload.threadId, {+ yield* projectionPendingTurnStartRepository.upsert({+ threadId: event.payload.threadId,messageId: event.payload.messageId,createdAt: event.payload.createdAt,});@@ -487,13 +492,16 @@ const makeOrchestrationProjectionPipeline = Effect.gen(function* () {}const existingTurn = yield* projectionThreadTurnRepository.getByTurnId({ turnId });- const pendingTurnStart = pendingTurnStartByThreadId.get(event.payload.threadId);+ const pendingTurnStart = yield* projectionPendingTurnStartRepository.getByThreadId({+ threadId: event.payload.threadId,+ });if (Option.isSome(existingTurn)) {yield* projectionThreadTurnRepository.upsert({...existingTurn.value,status: existingTurn.value.status === "completed" ? "completed" : "running",userMessageId:- existingTurn.value.userMessageId ?? pendingTurnStart?.messageId ?? null,+ existingTurn.value.userMessageId ??+ (Option.isSome(pendingTurnStart) ? pendingTurnStart.value.messageId : null),startedAt: existingTurn.value.startedAt,});} else {@@ -505,14 +513,18 @@ const makeOrchestrationProjectionPipeline = Effect.gen(function* () {threadId: event.payload.threadId,turnCount: nextTurnCount(existingThreadTurns),status: "running",- userMessageId: pendingTurnStart?.messageId ?? null,+ userMessageId: Option.isSome(pendingTurnStart) ? pendingTurnStart.value.messageId : null,assistantMessageId: null,- startedAt: pendingTurnStart?.createdAt ?? event.occurredAt,+ startedAt: Option.isSome(pendingTurnStart)+ ? pendingTurnStart.value.createdAt+ : event.occurredAt,completedAt: null,});}- pendingTurnStartByThreadId.delete(event.payload.threadId);+ yield* projectionPendingTurnStartRepository.deleteByThreadId({+ threadId: event.payload.threadId,+ });return;}@@ -837,9 +849,7 @@ const makeOrchestrationProjectionPipeline = Effect.gen(function* () {const bootstrap: OrchestrationProjectionPipelineShape["bootstrap"] = Effect.forEach(projectors,bootstrapProjector,- {- concurrency: 1,- },+ { concurrency: 1 },).pipe(Effect.asVoid,Effect.tap(() =>@@ -870,5 +880,6 @@ export const OrchestrationProjectionPipelineLive = Layer.effect(Layer.provideMerge(ProjectionThreadTurnRepositoryLive),Layer.provideMerge(ProjectionCheckpointRepositoryLive),Layer.provideMerge(ProjectionPendingApprovalRepositoryLive),+ Layer.provideMerge(ProjectionPendingTurnStartRepositoryLive),Layer.provideMerge(ProjectionStateRepositoryLive),);diff --git a/apps/server/src/orchestration/projector.test.ts b/apps/server/src/orchestration/projector.test.tsindex e03c260db..770744bc9 100644--- a/apps/server/src/orchestration/projector.test.ts+++ b/apps/server/src/orchestration/projector.test.ts@@ -502,4 +502,153 @@ describe("orchestration projector", () => {expect(thread?.checkpoints.map((checkpoint) => checkpoint.checkpointTurnCount)).toEqual([1]);expect(thread?.latestTurnId).toBe("turn-1");});++ it("does not fallback-retain messages tied to removed turn IDs", async () => {+ const createdAt = "2026-02-26T12:00:00.000Z";+ const model = createEmptyReadModel(createdAt);++ const afterCreate = await Effect.runPromise(+ projectEvent(+ model,+ makeEvent({+ sequence: 1,+ type: "thread.created",+ aggregateKind: "thread",+ aggregateId: "thread-revert",+ occurredAt: createdAt,+ commandId: "cmd-create-revert",+ payload: {+ threadId: "thread-revert",+ projectId: "project-1",+ title: "demo",+ model: "gpt-5.3-codex",+ branch: null,+ worktreePath: null,+ createdAt,+ updatedAt: createdAt,+ },+ }),+ ),+ );++ const events: ReadonlyArray<OrchestrationEvent> = [+ makeEvent({+ sequence: 2,+ type: "thread.turn-diff-completed",+ aggregateKind: "thread",+ aggregateId: "thread-revert",+ occurredAt: "2026-02-26T12:00:01.000Z",+ commandId: "cmd-turn-1",+ payload: {+ threadId: "thread-revert",+ turnId: "turn-1",+ checkpointTurnCount: 1,+ checkpointRef: "refs/t3/checkpoints/thread-revert/turn/1",+ status: "ready",+ files: [],+ assistantMessageId: "assistant-keep",+ completedAt: "2026-02-26T12:00:01.000Z",+ },+ }),+ makeEvent({+ sequence: 3,+ type: "thread.message-sent",+ aggregateKind: "thread",+ aggregateId: "thread-revert",+ occurredAt: "2026-02-26T12:00:01.100Z",+ commandId: "cmd-assistant-keep",+ payload: {+ threadId: "thread-revert",+ messageId: "assistant-keep",+ role: "assistant",+ text: "kept",+ turnId: "turn-1",+ streaming: false,+ createdAt: "2026-02-26T12:00:01.100Z",+ updatedAt: "2026-02-26T12:00:01.100Z",+ },+ }),+ makeEvent({+ sequence: 4,+ type: "thread.turn-diff-completed",+ aggregateKind: "thread",+ aggregateId: "thread-revert",+ occurredAt: "2026-02-26T12:00:02.000Z",+ commandId: "cmd-turn-2",+ payload: {+ threadId: "thread-revert",+ turnId: "turn-2",+ checkpointTurnCount: 2,+ checkpointRef: "refs/t3/checkpoints/thread-revert/turn/2",+ status: "ready",+ files: [],+ assistantMessageId: "assistant-remove",+ completedAt: "2026-02-26T12:00:02.000Z",+ },+ }),+ makeEvent({+ sequence: 5,+ type: "thread.message-sent",+ aggregateKind: "thread",+ aggregateId: "thread-revert",+ occurredAt: "2026-02-26T12:00:02.050Z",+ commandId: "cmd-user-remove",+ payload: {+ threadId: "thread-revert",+ messageId: "user-remove",+ role: "user",+ text: "removed",+ turnId: "turn-2",+ streaming: false,+ createdAt: "2026-02-26T12:00:02.050Z",+ updatedAt: "2026-02-26T12:00:02.050Z",+ },+ }),+ makeEvent({+ sequence: 6,+ type: "thread.message-sent",+ aggregateKind: "thread",+ aggregateId: "thread-revert",+ occurredAt: "2026-02-26T12:00:02.100Z",+ commandId: "cmd-assistant-remove",+ payload: {+ threadId: "thread-revert",+ messageId: "assistant-remove",+ role: "assistant",+ text: "removed",+ turnId: "turn-2",+ streaming: false,+ createdAt: "2026-02-26T12:00:02.100Z",+ updatedAt: "2026-02-26T12:00:02.100Z",+ },+ }),+ makeEvent({+ sequence: 7,+ type: "thread.reverted",+ aggregateKind: "thread",+ aggregateId: "thread-revert",+ occurredAt: "2026-02-26T12:00:03.000Z",+ commandId: "cmd-revert",+ payload: {+ threadId: "thread-revert",+ turnCount: 1,+ },+ }),+ ];++ const afterRevert = await events.reduce<Promise<ReturnType<typeof createEmptyReadModel>>>(+ (statePromise, event) =>+ statePromise.then((state) => Effect.runPromise(projectEvent(state, event))),+ Promise.resolve(afterCreate),+ );++ const thread = afterRevert.threads[0];+ expect(+ thread?.messages.map((message) => ({+ id: message.id,+ role: message.role,+ turnId: message.turnId,+ })),+ ).toEqual([{ id: "assistant-keep", role: "assistant", turnId: "turn-1" }]);+ });});diff --git a/apps/server/src/orchestration/projector.ts b/apps/server/src/orchestration/projector.tsindex 6a3f8fe9c..d17722d8c 100644--- a/apps/server/src/orchestration/projector.ts+++ b/apps/server/src/orchestration/projector.ts@@ -65,7 +65,12 @@ function retainThreadMessagesAfterRevert(const missingUserCount = Math.max(0, turnCount - retainedUserCount);if (missingUserCount > 0) {const fallbackUserMessages = messages- .filter((message) => message.role === "user" && !retainedMessageIds.has(message.id))+ .filter(+ (message) =>+ message.role === "user" &&+ !retainedMessageIds.has(message.id) &&+ (message.turnId === null || retainedTurnIds.has(message.turnId)),+ ).toSorted((left, right) =>left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),@@ -82,7 +87,12 @@ function retainThreadMessagesAfterRevert(const missingAssistantCount = Math.max(0, turnCount - retainedAssistantCount);if (missingAssistantCount > 0) {const fallbackAssistantMessages = messages- .filter((message) => message.role === "assistant" && !retainedMessageIds.has(message.id))+ .filter(+ (message) =>+ message.role === "assistant" &&+ !retainedMessageIds.has(message.id) &&+ (message.turnId === null || retainedTurnIds.has(message.turnId)),+ ).toSorted((left, right) =>left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),diff --git a/apps/server/src/persistence/Layers/ProjectionPendingTurnStarts.ts b/apps/server/src/persistence/Layers/ProjectionPendingTurnStarts.tsnew file mode 100644index 000000000..7d46dfdf5--- /dev/null+++ b/apps/server/src/persistence/Layers/ProjectionPendingTurnStarts.ts@@ -0,0 +1,92 @@+import * as SqlClient from "effect/unstable/sql/SqlClient";+import * as SqlSchema from "effect/unstable/sql/SqlSchema";+import { Effect, Layer } from "effect";++import { toPersistenceSqlError } from "../Errors.ts";+import {+ DeleteProjectionPendingTurnStartInput,+ GetProjectionPendingTurnStartInput,+ ProjectionPendingTurnStart,+ ProjectionPendingTurnStartRepository,+ type ProjectionPendingTurnStartRepositoryShape,+} from "../Services/ProjectionPendingTurnStarts.ts";++const makeProjectionPendingTurnStartRepository = Effect.gen(function* () {+ const sql = yield* SqlClient.SqlClient;++ const upsertProjectionPendingTurnStartRow = SqlSchema.void({+ Request: ProjectionPendingTurnStart,+ execute: (row) =>+ sql`+ INSERT INTO projection_pending_turn_starts (+ thread_id,+ message_id,+ created_at+ )+ VALUES (+ ${row.threadId},+ ${row.messageId},+ ${row.createdAt}+ )+ ON CONFLICT (thread_id)+ DO UPDATE SET+ message_id = excluded.message_id,+ created_at = excluded.created_at+ `,+ });++ const getProjectionPendingTurnStartRow = SqlSchema.findOneOption({+ Request: GetProjectionPendingTurnStartInput,+ Result: ProjectionPendingTurnStart,+ execute: ({ threadId }) =>+ sql`+ SELECT+ thread_id AS "threadId",+ message_id AS "messageId",+ created_at AS "createdAt"+ FROM projection_pending_turn_starts+ WHERE thread_id = ${threadId}+ `,+ });++ const deleteProjectionPendingTurnStartRow = SqlSchema.void({+ Request: DeleteProjectionPendingTurnStartInput,+ execute: ({ threadId }) =>+ sql`+ DELETE FROM projection_pending_turn_starts+ WHERE thread_id = ${threadId}+ `,+ });++ const upsert: ProjectionPendingTurnStartRepositoryShape["upsert"] = (row) =>+ upsertProjectionPendingTurnStartRow(row).pipe(+ Effect.mapError(toPersistenceSqlError("ProjectionPendingTurnStartRepository.upsert:query")),+ );++ const getByThreadId: ProjectionPendingTurnStartRepositoryShape["getByThreadId"] = (input) =>+ getProjectionPendingTurnStartRow(input).pipe(+ Effect.mapError(+ toPersistenceSqlError("ProjectionPendingTurnStartRepository.getByThreadId:query"),+ ),+ );++ const deleteByThreadId: ProjectionPendingTurnStartRepositoryShape["deleteByThreadId"] = (+ input,+ ) =>+ deleteProjectionPendingTurnStartRow(input).pipe(+ Effect.mapError(+ toPersistenceSqlError("ProjectionPendingTurnStartRepository.deleteByThreadId:query"),+ ),+ );++ return {+ upsert,+ getByThreadId,+ deleteByThreadId,+ } satisfies ProjectionPendingTurnStartRepositoryShape;+});++export const ProjectionPendingTurnStartRepositoryLive = Layer.effect(+ ProjectionPendingTurnStartRepository,+ makeProjectionPendingTurnStartRepository,+);diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.tsindex 3779c16d4..7d7325851 100644--- a/apps/server/src/persistence/Migrations.ts+++ b/apps/server/src/persistence/Migrations.ts@@ -17,6 +17,7 @@ import Migration0002 from "./Migrations/002_OrchestrationCommandReceipts.ts";import Migration0003 from "./Migrations/003_CheckpointDiffBlobs.ts";import Migration0004 from "./Migrations/004_ProviderSessionRuntime.ts";import Migration0005 from "./Migrations/005_Projections.ts";+import Migration0006 from "./Migrations/006_ProjectionPendingTurnStarts.ts";/*** Migration loader with all migrations defined inline.@@ -34,6 +35,7 @@ const loader = Migrator.fromRecord({"3_CheckpointDiffBlobs": Migration0003,"4_ProviderSessionRuntime": Migration0004,"5_Projections": Migration0005,+ "6_ProjectionPendingTurnStarts": Migration0006,});/**diff --git a/apps/server/src/persistence/Migrations/006_ProjectionPendingTurnStarts.ts b/apps/server/src/persistence/Migrations/006_ProjectionPendingTurnStarts.tsnew file mode 100644index 000000000..5e000a73b--- /dev/null+++ b/apps/server/src/persistence/Migrations/006_ProjectionPendingTurnStarts.ts@@ -0,0 +1,14 @@+import { Effect } from "effect";+import * as SqlClient from "effect/unstable/sql/SqlClient";++export default Effect.gen(function* () {+ const sql = yield* SqlClient.SqlClient;++ yield* sql`+ CREATE TABLE IF NOT EXISTS projection_pending_turn_starts (+ thread_id TEXT PRIMARY KEY,+ message_id TEXT NOT NULL,+ created_at TEXT NOT NULL+ )+ `;+});diff --git a/apps/server/src/persistence/Services/ProjectionPendingTurnStarts.ts b/apps/server/src/persistence/Services/ProjectionPendingTurnStarts.tsnew file mode 100644index 000000000..58c2572fe--- /dev/null+++ b/apps/server/src/persistence/Services/ProjectionPendingTurnStarts.ts@@ -0,0 +1,41 @@+import { IsoDateTime, MessageId, ThreadId } from "@t3tools/contracts";+import { Option, Schema, ServiceMap } from "effect";+import type { Effect } from "effect";++import type { ProjectionRepositoryError } from "../Errors.ts";++export const ProjectionPendingTurnStart = Schema.Struct({+ threadId: ThreadId,+ messageId: MessageId,+ createdAt: IsoDateTime,+});+export type ProjectionPendingTurnStart = typeof ProjectionPendingTurnStart.Type;++export const GetProjectionPendingTurnStartInput = Schema.Struct({+ threadId: ThreadId,+});+export type GetProjectionPendingTurnStartInput = typeof GetProjectionPendingTurnStartInput.Type;++export const DeleteProjectionPendingTurnStartInput = Schema.Struct({+ threadId: ThreadId,+});+export type DeleteProjectionPendingTurnStartInput = typeof DeleteProjectionPendingTurnStartInput.Type;++export interface ProjectionPendingTurnStartRepositoryShape {+ readonly upsert: (+ row: ProjectionPendingTurnStart,+ ) => Effect.Effect<void, ProjectionRepositoryError>;++ readonly getByThreadId: (+ input: GetProjectionPendingTurnStartInput,+ ) => Effect.Effect<Option.Option<ProjectionPendingTurnStart>, ProjectionRepositoryError>;++ readonly deleteByThreadId: (+ input: DeleteProjectionPendingTurnStartInput,+ ) => Effect.Effect<void, ProjectionRepositoryError>;+}++export class ProjectionPendingTurnStartRepository extends ServiceMap.Service<+ ProjectionPendingTurnStartRepository,+ ProjectionPendingTurnStartRepositoryShape+>()("persistence/ProjectionPendingTurnStartRepository") {}