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: consume plans on implementation (#1133)
Utkarsh Patil0de5742b0488
diff --git a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts b/apps/server/src/orchestration/Layers/ProjectionPipeline.tsindex 6ae94105a..ce633aeca 100644--- a/apps/server/src/orchestration/Layers/ProjectionPipeline.ts+++ b/apps/server/src/orchestration/Layers/ProjectionPipeline.ts@@ -653,6 +653,8 @@ const makeOrchestrationProjectionPipeline = Effect.gen(function* () {threadId: event.payload.threadId,turnId: event.payload.proposedPlan.turnId,planMarkdown: event.payload.proposedPlan.planMarkdown,+ implementedAt: event.payload.proposedPlan.implementedAt,+ implementationThreadId: event.payload.proposedPlan.implementationThreadId,createdAt: event.payload.proposedPlan.createdAt,updatedAt: event.payload.proposedPlan.updatedAt,});@@ -775,6 +777,8 @@ const makeOrchestrationProjectionPipeline = Effect.gen(function* () {yield* projectionTurnRepository.replacePendingTurnStart({threadId: event.payload.threadId,messageId: event.payload.messageId,+ sourceProposedPlanThreadId: event.payload.sourceProposedPlan?.threadId ?? null,+ sourceProposedPlanId: event.payload.sourceProposedPlan?.planId ?? null,requestedAt: event.payload.createdAt,});return;diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.tsindex fc7db5480..9bfe581de 100644--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts@@ -26,6 +26,7 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {yield* sql`DELETE FROM projection_projects`;yield* sql`DELETE FROM projection_state`;+ yield* sql`DELETE FROM projection_thread_proposed_plans`;yield* sql`DELETE FROM projection_turns`;yield* sql`@@ -101,6 +102,29 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {)`;+ yield* sql`+ INSERT INTO projection_thread_proposed_plans (+ plan_id,+ thread_id,+ turn_id,+ plan_markdown,+ implemented_at,+ implementation_thread_id,+ created_at,+ updated_at+ )+ VALUES (+ 'plan-1',+ 'thread-1',+ 'turn-1',+ '# Ship it',+ '2026-02-24T00:00:05.500Z',+ 'thread-2',+ '2026-02-24T00:00:05.000Z',+ '2026-02-24T00:00:05.500Z'+ )+ `;+yield* sql`INSERT INTO projection_thread_activities (activity_id,@@ -253,7 +277,17 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {updatedAt: "2026-02-24T00:00:05.000Z",},],- proposedPlans: [],+ proposedPlans: [+ {+ id: "plan-1",+ turnId: asTurnId("turn-1"),+ planMarkdown: "# Ship it",+ implementedAt: "2026-02-24T00:00:05.500Z",+ implementationThreadId: ThreadId.makeUnsafe("thread-2"),+ createdAt: "2026-02-24T00:00:05.000Z",+ updatedAt: "2026-02-24T00:00:05.500Z",+ },+ ],activities: [{id: asEventId("activity-1"),diff --git a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.tsindex 5fd38a540..1b5134fbc 100644--- a/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts+++ b/apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts@@ -200,6 +200,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {thread_id AS "threadId",turn_id AS "turnId",plan_markdown AS "planMarkdown",+ implemented_at AS "implementedAt",+ implementation_thread_id AS "implementationThreadId",created_at AS "createdAt",updated_at AS "updatedAt"FROM projection_thread_proposed_plans@@ -435,6 +437,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {id: row.planId,turnId: row.turnId,planMarkdown: row.planMarkdown,+ implementedAt: row.implementedAt,+ implementationThreadId: row.implementationThreadId,createdAt: row.createdAt,updatedAt: row.updatedAt,});diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.tsindex b6b48c7ed..770f25ee1 100644--- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts+++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.test.ts@@ -2,7 +2,11 @@ import fs from "node:fs";import os from "node:os";import path from "node:path";-import type { OrchestrationReadModel, ProviderRuntimeEvent } from "@t3tools/contracts";+import type {+ OrchestrationReadModel,+ ProviderRuntimeEvent,+ ProviderSession,+} from "@t3tools/contracts";import {ApprovalRequestId,CommandId,@@ -57,6 +61,7 @@ type LegacyProviderRuntimeEvent = {function createProviderServiceHarness() {const runtimeEventPubSub = Effect.runSync(PubSub.unbounded<ProviderRuntimeEvent>());+ const runtimeSessions: ProviderSession[] = [];const unsupported = () => Effect.die(new Error("Unsupported provider call in test")) as never;const service: ProviderServiceShape = {@@ -66,12 +71,21 @@ function createProviderServiceHarness() {respondToRequest: () => unsupported(),respondToUserInput: () => unsupported(),stopSession: () => unsupported(),- listSessions: () => Effect.succeed([]),+ listSessions: () => Effect.succeed([...runtimeSessions]),getCapabilities: () => Effect.succeed({ sessionModelSwitch: "in-session" }),rollbackConversation: () => unsupported(),streamEvents: Stream.fromPubSub(runtimeEventPubSub),};+ const setSession = (session: ProviderSession): void => {+ const existingIndex = runtimeSessions.findIndex((entry) => entry.threadId === session.threadId);+ if (existingIndex >= 0) {+ runtimeSessions[existingIndex] = session;+ return;+ }+ runtimeSessions.push(session);+ };+const emit = (event: LegacyProviderRuntimeEvent): void => {Effect.runSync(PubSub.publish(runtimeEventPubSub, event as unknown as ProviderRuntimeEvent));};@@ -79,6 +93,7 @@ function createProviderServiceHarness() {return {service,emit,+ setSession,};}@@ -86,11 +101,12 @@ async function waitForThread(engine: OrchestrationEngineShape,predicate: (thread: ProviderRuntimeTestThread) => boolean,timeoutMs = 2000,+ threadId: ThreadId = asThreadId("thread-1"),) {const deadline = Date.now() + timeoutMs;const poll = async (): Promise<ProviderRuntimeTestThread> => {const readModel = await Effect.runPromise(engine.getReadModel());- const thread = readModel.threads.find((entry) => entry.id === ThreadId.makeUnsafe("thread-1"));+ const thread = readModel.threads.find((entry) => entry.id === threadId);if (thread && predicate(thread)) {return thread;}@@ -150,6 +166,7 @@ describe("ProviderRuntimeIngestion", () => {);const layer = ProviderRuntimeIngestionLive.pipe(Layer.provideMerge(orchestrationLayer),+ Layer.provideMerge(SqlitePersistenceMemory),Layer.provideMerge(Layer.succeed(ProviderService, provider.service)),Layer.provideMerge(ServerConfig.layerTest(process.cwd(), process.cwd())),Layer.provideMerge(NodeServices.layer),@@ -205,10 +222,19 @@ describe("ProviderRuntimeIngestion", () => {createdAt,}),);+ provider.setSession({+ provider: "codex",+ status: "ready",+ runtimeMode: "approval-required",+ threadId: ThreadId.makeUnsafe("thread-1"),+ createdAt,+ updatedAt: createdAt,+ });return {engine,emit: provider.emit,+ setProviderSession: provider.setSession,drain,};}@@ -628,6 +654,496 @@ describe("ProviderRuntimeIngestion", () => {);});+ it("marks the source proposed plan implemented only after the target turn starts", async () => {+ const harness = await createHarness();+ const sourceThreadId = asThreadId("thread-plan");+ const targetThreadId = asThreadId("thread-implement");+ const sourceTurnId = asTurnId("turn-plan-source");+ const targetTurnId = asTurnId("turn-plan-implement");+ const createdAt = new Date().toISOString();++ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.create",+ commandId: CommandId.makeUnsafe("cmd-thread-create-plan-source"),+ threadId: sourceThreadId,+ projectId: asProjectId("project-1"),+ title: "Plan Source",+ model: "gpt-5-codex",+ interactionMode: "plan",+ runtimeMode: "approval-required",+ branch: null,+ worktreePath: null,+ createdAt,+ }),+ );+ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.session.set",+ commandId: CommandId.makeUnsafe("cmd-session-set-plan-source"),+ threadId: sourceThreadId,+ session: {+ threadId: sourceThreadId,+ status: "ready",+ providerName: "codex",+ runtimeMode: "approval-required",+ activeTurnId: null,+ updatedAt: createdAt,+ lastError: null,+ },+ createdAt,+ }),+ );+ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.create",+ commandId: CommandId.makeUnsafe("cmd-thread-create-plan-target"),+ threadId: targetThreadId,+ projectId: asProjectId("project-1"),+ title: "Plan Target",+ model: "gpt-5-codex",+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,+ runtimeMode: "approval-required",+ branch: null,+ worktreePath: null,+ createdAt,+ }),+ );+ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.session.set",+ commandId: CommandId.makeUnsafe("cmd-session-set-plan-target"),+ threadId: targetThreadId,+ session: {+ threadId: targetThreadId,+ status: "ready",+ providerName: "codex",+ runtimeMode: "approval-required",+ activeTurnId: null,+ updatedAt: createdAt,+ lastError: null,+ },+ createdAt,+ }),+ );+ harness.setProviderSession({+ provider: "codex",+ status: "ready",+ runtimeMode: "approval-required",+ threadId: targetThreadId,+ createdAt,+ updatedAt: createdAt,+ activeTurnId: targetTurnId,+ });++ harness.emit({+ type: "turn.proposed.completed",+ eventId: asEventId("evt-plan-source-completed"),+ provider: "codex",+ createdAt,+ threadId: sourceThreadId,+ turnId: sourceTurnId,+ payload: {+ planMarkdown: "# Source plan",+ },+ });++ const sourceThreadWithPlan = await waitForThread(+ harness.engine,+ (thread) =>+ thread.proposedPlans.some(+ (proposedPlan: ProviderRuntimeTestProposedPlan) =>+ proposedPlan.id === "plan:thread-plan:turn:turn-plan-source" &&+ proposedPlan.implementedAt === null,+ ),+ 2_000,+ sourceThreadId,+ );+ const sourcePlan = sourceThreadWithPlan.proposedPlans.find(+ (entry: ProviderRuntimeTestProposedPlan) =>+ entry.id === "plan:thread-plan:turn:turn-plan-source",+ );+ expect(sourcePlan).toBeDefined();+ if (!sourcePlan) {+ throw new Error("Expected source plan to exist.");+ }++ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.turn.start",+ commandId: CommandId.makeUnsafe("cmd-turn-start-plan-target"),+ threadId: targetThreadId,+ message: {+ messageId: asMessageId("msg-plan-target"),+ role: "user",+ text: "PLEASE IMPLEMENT THIS PLAN:\n# Source plan",+ attachments: [],+ },+ sourceProposedPlan: {+ threadId: sourceThreadId,+ planId: sourcePlan.id,+ },+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,+ runtimeMode: "approval-required",+ createdAt: new Date().toISOString(),+ }),+ );++ const sourceThreadBeforeStart = await waitForThread(+ harness.engine,+ (thread) =>+ thread.proposedPlans.some(+ (proposedPlan: ProviderRuntimeTestProposedPlan) =>+ proposedPlan.id === sourcePlan.id && proposedPlan.implementedAt === null,+ ),+ 2_000,+ sourceThreadId,+ );+ expect(+ sourceThreadBeforeStart.proposedPlans.find((entry) => entry.id === sourcePlan.id),+ ).toMatchObject({+ implementedAt: null,+ implementationThreadId: null,+ });++ harness.emit({+ type: "turn.started",+ eventId: asEventId("evt-plan-target-started"),+ provider: "codex",+ createdAt: new Date().toISOString(),+ threadId: targetThreadId,+ turnId: targetTurnId,+ });++ const sourceThreadAfterStart = await waitForThread(+ harness.engine,+ (thread) =>+ thread.proposedPlans.some(+ (proposedPlan: ProviderRuntimeTestProposedPlan) =>+ proposedPlan.id === sourcePlan.id &&+ proposedPlan.implementedAt !== null &&+ proposedPlan.implementationThreadId === targetThreadId,+ ),+ 2_000,+ sourceThreadId,+ );+ expect(+ sourceThreadAfterStart.proposedPlans.find((entry) => entry.id === sourcePlan.id),+ ).toMatchObject({+ implementationThreadId: "thread-implement",+ });+ });++ it("does not mark the source proposed plan implemented for a rejected turn.started event", async () => {+ const harness = await createHarness();+ const sourceThreadId = asThreadId("thread-plan");+ const targetThreadId = asThreadId("thread-1");+ const sourceTurnId = asTurnId("turn-plan-source");+ const activeTurnId = asTurnId("turn-already-running");+ const staleTurnId = asTurnId("turn-stale-start");+ const createdAt = new Date().toISOString();++ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.create",+ commandId: CommandId.makeUnsafe("cmd-thread-create-plan-source-guarded"),+ threadId: sourceThreadId,+ projectId: asProjectId("project-1"),+ title: "Plan Source",+ model: "gpt-5-codex",+ interactionMode: "plan",+ runtimeMode: "approval-required",+ branch: null,+ worktreePath: null,+ createdAt,+ }),+ );+ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.session.set",+ commandId: CommandId.makeUnsafe("cmd-session-set-plan-source-guarded"),+ threadId: sourceThreadId,+ session: {+ threadId: sourceThreadId,+ status: "ready",+ providerName: "codex",+ runtimeMode: "approval-required",+ activeTurnId: null,+ updatedAt: createdAt,+ lastError: null,+ },+ createdAt,+ }),+ );+ harness.setProviderSession({+ provider: "codex",+ status: "running",+ runtimeMode: "approval-required",+ threadId: targetThreadId,+ createdAt,+ updatedAt: createdAt,+ activeTurnId,+ });++ harness.emit({+ type: "turn.started",+ eventId: asEventId("evt-turn-started-already-running"),+ provider: "codex",+ createdAt,+ threadId: targetThreadId,+ turnId: activeTurnId,+ });++ await waitForThread(+ harness.engine,+ (thread) =>+ thread.session?.status === "running" && thread.session?.activeTurnId === activeTurnId,+ 2_000,+ targetThreadId,+ );++ harness.emit({+ type: "turn.proposed.completed",+ eventId: asEventId("evt-plan-source-completed-guarded"),+ provider: "codex",+ createdAt,+ threadId: sourceThreadId,+ turnId: sourceTurnId,+ payload: {+ planMarkdown: "# Source plan",+ },+ });++ const sourceThreadWithPlan = await waitForThread(+ harness.engine,+ (thread) =>+ thread.proposedPlans.some(+ (proposedPlan: ProviderRuntimeTestProposedPlan) =>+ proposedPlan.id === "plan:thread-plan:turn:turn-plan-source" &&+ proposedPlan.implementedAt === null,+ ),+ 2_000,+ sourceThreadId,+ );+ const sourcePlan = sourceThreadWithPlan.proposedPlans.find(+ (entry: ProviderRuntimeTestProposedPlan) =>+ entry.id === "plan:thread-plan:turn:turn-plan-source",+ );+ expect(sourcePlan).toBeDefined();+ if (!sourcePlan) {+ throw new Error("Expected source plan to exist.");+ }++ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.turn.start",+ commandId: CommandId.makeUnsafe("cmd-turn-start-plan-target-guarded"),+ threadId: targetThreadId,+ message: {+ messageId: asMessageId("msg-plan-target-guarded"),+ role: "user",+ text: "PLEASE IMPLEMENT THIS PLAN:\n# Source plan",+ attachments: [],+ },+ sourceProposedPlan: {+ threadId: sourceThreadId,+ planId: sourcePlan.id,+ },+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,+ runtimeMode: "approval-required",+ createdAt: new Date().toISOString(),+ }),+ );++ harness.emit({+ type: "turn.started",+ eventId: asEventId("evt-turn-started-stale-plan-implementation"),+ provider: "codex",+ createdAt: new Date().toISOString(),+ threadId: targetThreadId,+ turnId: staleTurnId,+ });++ await harness.drain();++ const readModel = await Effect.runPromise(harness.engine.getReadModel());+ const sourceThreadAfterRejectedStart = readModel.threads.find(+ (entry) => entry.id === sourceThreadId,+ );+ expect(+ sourceThreadAfterRejectedStart?.proposedPlans.find((entry) => entry.id === sourcePlan.id),+ ).toMatchObject({+ implementedAt: null,+ implementationThreadId: null,+ });++ const targetThreadAfterRejectedStart = readModel.threads.find(+ (entry) => entry.id === targetThreadId,+ );+ expect(targetThreadAfterRejectedStart?.session?.status).toBe("running");+ expect(targetThreadAfterRejectedStart?.session?.activeTurnId).toBe(activeTurnId);+ });++ it("does not mark the source proposed plan implemented for an unrelated turn.started when no thread active turn is tracked", async () => {+ const harness = await createHarness();+ const sourceThreadId = asThreadId("thread-plan");+ const targetThreadId = asThreadId("thread-implement");+ const sourceTurnId = asTurnId("turn-plan-source");+ const expectedTurnId = asTurnId("turn-plan-implement");+ const replayedTurnId = asTurnId("turn-replayed");+ const createdAt = new Date().toISOString();++ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.create",+ commandId: CommandId.makeUnsafe("cmd-thread-create-plan-source-unrelated"),+ threadId: sourceThreadId,+ projectId: asProjectId("project-1"),+ title: "Plan Source",+ model: "gpt-5-codex",+ interactionMode: "plan",+ runtimeMode: "approval-required",+ branch: null,+ worktreePath: null,+ createdAt,+ }),+ );+ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.session.set",+ commandId: CommandId.makeUnsafe("cmd-session-set-plan-source-unrelated"),+ threadId: sourceThreadId,+ session: {+ threadId: sourceThreadId,+ status: "ready",+ providerName: "codex",+ runtimeMode: "approval-required",+ activeTurnId: null,+ updatedAt: createdAt,+ lastError: null,+ },+ createdAt,+ }),+ );+ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.create",+ commandId: CommandId.makeUnsafe("cmd-thread-create-plan-target-unrelated"),+ threadId: targetThreadId,+ projectId: asProjectId("project-1"),+ title: "Plan Target",+ model: "gpt-5-codex",+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,+ runtimeMode: "approval-required",+ branch: null,+ worktreePath: null,+ createdAt,+ }),+ );+ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.session.set",+ commandId: CommandId.makeUnsafe("cmd-session-set-plan-target-unrelated"),+ threadId: targetThreadId,+ session: {+ threadId: targetThreadId,+ status: "ready",+ providerName: "codex",+ runtimeMode: "approval-required",+ activeTurnId: null,+ updatedAt: createdAt,+ lastError: null,+ },+ createdAt,+ }),+ );++ harness.emit({+ type: "turn.proposed.completed",+ eventId: asEventId("evt-plan-source-completed-unrelated"),+ provider: "codex",+ createdAt,+ threadId: sourceThreadId,+ turnId: sourceTurnId,+ payload: {+ planMarkdown: "# Source plan",+ },+ });++ const sourceThreadWithPlan = await waitForThread(+ harness.engine,+ (thread) =>+ thread.proposedPlans.some(+ (proposedPlan: ProviderRuntimeTestProposedPlan) =>+ proposedPlan.id === "plan:thread-plan:turn:turn-plan-source" &&+ proposedPlan.implementedAt === null,+ ),+ 2_000,+ sourceThreadId,+ );+ const sourcePlan = sourceThreadWithPlan.proposedPlans.find(+ (entry: ProviderRuntimeTestProposedPlan) =>+ entry.id === "plan:thread-plan:turn:turn-plan-source",+ );+ expect(sourcePlan).toBeDefined();+ if (!sourcePlan) {+ throw new Error("Expected source plan to exist.");+ }++ await Effect.runPromise(+ harness.engine.dispatch({+ type: "thread.turn.start",+ commandId: CommandId.makeUnsafe("cmd-turn-start-plan-target-unrelated"),+ threadId: targetThreadId,+ message: {+ messageId: asMessageId("msg-plan-target-unrelated"),+ role: "user",+ text: "PLEASE IMPLEMENT THIS PLAN:\n# Source plan",+ attachments: [],+ },+ sourceProposedPlan: {+ threadId: sourceThreadId,+ planId: sourcePlan.id,+ },+ interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,+ runtimeMode: "approval-required",+ createdAt: new Date().toISOString(),+ }),+ );++ harness.setProviderSession({+ provider: "codex",+ status: "running",+ runtimeMode: "approval-required",+ threadId: targetThreadId,+ createdAt,+ updatedAt: createdAt,+ activeTurnId: expectedTurnId,+ });++ harness.emit({+ type: "turn.started",+ eventId: asEventId("evt-turn-started-unrelated-plan-implementation"),+ provider: "codex",+ createdAt: new Date().toISOString(),+ threadId: targetThreadId,+ turnId: replayedTurnId,+ });++ await harness.drain();++ const readModel = await Effect.runPromise(harness.engine.getReadModel());+ const sourceThreadAfterUnrelatedStart = readModel.threads.find(+ (entry) => entry.id === sourceThreadId,+ );+ expect(+ sourceThreadAfterUnrelatedStart?.proposedPlans.find((entry) => entry.id === sourcePlan.id),+ ).toMatchObject({+ implementedAt: null,+ implementationThreadId: null,+ });+ });+it("finalizes buffered proposed-plan deltas into a first-class proposed plan on turn completion", async () => {const harness = await createHarness();const now = new Date().toISOString();diff --git a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.tsindex 417e93c8d..ed58664b8 100644--- a/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts+++ b/apps/server/src/orchestration/Layers/ProviderRuntimeIngestion.ts@@ -4,6 +4,7 @@ import {CommandId,MessageId,type OrchestrationEvent,+ type OrchestrationProposedPlanId,CheckpointRef,isToolLifecycleItemType,ThreadId,@@ -15,6 +16,8 @@ import { Cache, Cause, Duration, Effect, Layer, Option, Ref, Stream } from "effeimport { makeDrainableWorker } from "@t3tools/shared/DrainableWorker";import { ProviderService } from "../../provider/Services/ProviderService.ts";+import { ProjectionTurnRepository } from "../../persistence/Services/ProjectionTurns.ts";+import { ProjectionTurnRepositoryLive } from "../../persistence/Layers/ProjectionTurns.ts";import { resolveThreadWorkspaceCwd } from "../../checkpointing/Utils.ts";import { isGitRepository } from "../../git/isRepo.ts";import { OrchestrationEngineService } from "../Services/OrchestrationEngine.ts";@@ -480,6 +483,7 @@ function runtimeEventToActivities(const make = Effect.gen(function* () {const orchestrationEngine = yield* OrchestrationEngineService;const providerService = yield* ProviderService;+ const projectionTurnRepository = yield* ProjectionTurnRepository;const assistantDeliveryModeRef = yield* Ref.make<AssistantDeliveryMode>(DEFAULT_ASSISTANT_DELIVERY_MODE,@@ -671,6 +675,8 @@ const make = Effect.gen(function* () {threadProposedPlans: ReadonlyArray<{id: string;createdAt: string;+ implementedAt: string | null;+ implementationThreadId: ThreadId | null;}>;planId: string;turnId?: TurnId;@@ -693,6 +699,8 @@ const make = Effect.gen(function* () {id: input.planId,turnId: input.turnId ?? null,planMarkdown,+ implementedAt: existingPlan?.implementedAt ?? null,+ implementationThreadId: existingPlan?.implementationThreadId ?? null,createdAt: existingPlan?.createdAt ?? input.createdAt,updatedAt: input.updatedAt,},@@ -706,6 +714,8 @@ const make = Effect.gen(function* () {threadProposedPlans: ReadonlyArray<{id: string;createdAt: string;+ implementedAt: string | null;+ implementationThreadId: ThreadId | null;}>;planId: string;turnId?: TurnId;@@ -772,6 +782,79 @@ const make = Effect.gen(function* () {).pipe(Effect.asVoid);});+ const getSourceProposedPlanReferenceForPendingTurnStart = Effect.fnUntraced(function* (+ threadId: ThreadId,+ ) {+ const pendingTurnStart = yield* projectionTurnRepository.getPendingTurnStartByThreadId({+ threadId,+ });+ if (Option.isNone(pendingTurnStart)) {+ return null;+ }++ const sourceThreadId = pendingTurnStart.value.sourceProposedPlanThreadId;+ const sourcePlanId = pendingTurnStart.value.sourceProposedPlanId;+ if (sourceThreadId === null || sourcePlanId === null) {+ return null;+ }++ return {+ sourceThreadId,+ sourcePlanId,+ } as const;+ });++ const getExpectedProviderTurnIdForThread = Effect.fnUntraced(function* (threadId: ThreadId) {+ const sessions = yield* providerService.listSessions();+ const session = sessions.find((entry) => entry.threadId === threadId);+ return session?.activeTurnId;+ });++ const getSourceProposedPlanReferenceForAcceptedTurnStart = Effect.fnUntraced(function* (+ threadId: ThreadId,+ eventTurnId: TurnId | undefined,+ ) {+ if (eventTurnId === undefined) {+ return null;+ }++ const expectedTurnId = yield* getExpectedProviderTurnIdForThread(threadId);+ if (!sameId(expectedTurnId, eventTurnId)) {+ return null;+ }++ return yield* getSourceProposedPlanReferenceForPendingTurnStart(threadId);+ });++ const markSourceProposedPlanImplemented = Effect.fnUntraced(function* (+ sourceThreadId: ThreadId,+ sourcePlanId: OrchestrationProposedPlanId,+ implementationThreadId: ThreadId,+ implementedAt: string,+ ) {+ const readModel = yield* orchestrationEngine.getReadModel();+ const sourceThread = readModel.threads.find((entry) => entry.id === sourceThreadId);+ const sourcePlan = sourceThread?.proposedPlans.find((entry) => entry.id === sourcePlanId);+ if (!sourceThread || !sourcePlan || sourcePlan.implementedAt !== null) {+ return;+ }++ yield* orchestrationEngine.dispatch({+ type: "thread.proposed-plan.upsert",+ commandId: CommandId.makeUnsafe(+ `provider:source-proposed-plan-implemented:${implementationThreadId}:${crypto.randomUUID()}`,+ ),+ threadId: sourceThread.id,+ proposedPlan: {+ ...sourcePlan,+ implementedAt,+ implementationThreadId,+ updatedAt: implementedAt,+ },+ createdAt: implementedAt,+ });+ });+const processRuntimeEvent = (event: ProviderRuntimeEvent) =>Effect.gen(function* () {const readModel = yield* orchestrationEngine.getReadModel();@@ -812,6 +895,10 @@ const make = Effect.gen(function* () {return true;}})();+ const acceptedTurnStartedSourcePlan =+ event.type === "turn.started" && shouldApplyThreadLifecycle+ ? yield* getSourceProposedPlanReferenceForAcceptedTurnStart(thread.id, eventTurnId)+ : null;if (event.type === "session.started" ||@@ -854,6 +941,26 @@ const make = Effect.gen(function* () {: (thread.session?.lastError ?? null);if (shouldApplyThreadLifecycle) {+ if (event.type === "turn.started" && acceptedTurnStartedSourcePlan !== null) {+ yield* markSourceProposedPlanImplemented(+ acceptedTurnStartedSourcePlan.sourceThreadId,+ acceptedTurnStartedSourcePlan.sourcePlanId,+ thread.id,+ now,+ ).pipe(+ Effect.catchCause((cause) =>+ Effect.logWarning(+ "provider runtime ingestion failed to mark source proposed plan",+ {+ eventId: event.eventId,+ eventType: event.type,+ cause: Cause.pretty(cause),+ },+ ),+ ),+ );+ }+yield* orchestrationEngine.dispatch({type: "thread.session.set",commandId: providerCommandId(event, "thread-session-set"),@@ -1144,4 +1251,7 @@ const make = Effect.gen(function* () {} satisfies ProviderRuntimeIngestionShape;});-export const ProviderRuntimeIngestionLive = Layer.effect(ProviderRuntimeIngestionService, make);+export const ProviderRuntimeIngestionLive = Layer.effect(+ ProviderRuntimeIngestionService,+ make,+).pipe(Layer.provide(ProjectionTurnRepositoryLive));diff --git a/apps/server/src/orchestration/decider.ts b/apps/server/src/orchestration/decider.tsindex eea41a2b3..6ea4c5175 100644--- a/apps/server/src/orchestration/decider.ts+++ b/apps/server/src/orchestration/decider.ts@@ -262,11 +262,35 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"}case "thread.turn.start": {- yield* requireThread({+ const targetThread = yield* requireThread({readModel,command,threadId: command.threadId,});+ const sourceProposedPlan = command.sourceProposedPlan;+ const sourceThread = sourceProposedPlan+ ? yield* requireThread({+ readModel,+ command,+ threadId: sourceProposedPlan.threadId,+ })+ : null;+ const sourcePlan =+ sourceProposedPlan && sourceThread+ ? sourceThread.proposedPlans.find((entry) => entry.id === sourceProposedPlan.planId)+ : null;+ if (sourceProposedPlan && !sourcePlan) {+ return yield* new OrchestrationCommandInvariantError({+ commandType: command.type,+ detail: `Proposed plan '${sourceProposedPlan.planId}' does not exist on thread '${sourceProposedPlan.threadId}'.`,+ });+ }+ if (sourceThread && sourceThread.projectId !== targetThread.projectId) {+ return yield* new OrchestrationCommandInvariantError({+ commandType: command.type,+ detail: `Proposed plan '${sourceProposedPlan?.planId}' belongs to thread '${sourceThread.id}' in a different project.`,+ });+ }const userMessageEvent: Omit<OrchestrationEvent, "sequence"> = {...withEventBase({aggregateKind: "thread",@@ -306,12 +330,9 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"? { providerOptions: command.providerOptions }: {}),assistantDeliveryMode: command.assistantDeliveryMode ?? DEFAULT_ASSISTANT_DELIVERY_MODE,- runtimeMode:- readModel.threads.find((entry) => entry.id === command.threadId)?.runtimeMode ??- command.runtimeMode,- interactionMode:- readModel.threads.find((entry) => entry.id === command.threadId)?.interactionMode ??- command.interactionMode,+ runtimeMode: targetThread.runtimeMode,+ interactionMode: targetThread.interactionMode,+ ...(sourceProposedPlan !== undefined ? { sourceProposedPlan } : {}),createdAt: command.createdAt,},};diff --git a/apps/server/src/persistence/Layers/ProjectionThreadProposedPlans.ts b/apps/server/src/persistence/Layers/ProjectionThreadProposedPlans.tsindex 3d103592f..ccd322feb 100644--- a/apps/server/src/persistence/Layers/ProjectionThreadProposedPlans.ts+++ b/apps/server/src/persistence/Layers/ProjectionThreadProposedPlans.ts@@ -22,6 +22,8 @@ const makeProjectionThreadProposedPlanRepository = Effect.gen(function* () {thread_id,turn_id,plan_markdown,+ implemented_at,+ implementation_thread_id,created_at,updated_at)@@ -30,6 +32,8 @@ const makeProjectionThreadProposedPlanRepository = Effect.gen(function* () {${row.threadId},${row.turnId},${row.planMarkdown},+ ${row.implementedAt},+ ${row.implementationThreadId},${row.createdAt},${row.updatedAt})@@ -38,6 +42,8 @@ const makeProjectionThreadProposedPlanRepository = Effect.gen(function* () {thread_id = excluded.thread_id,turn_id = excluded.turn_id,plan_markdown = excluded.plan_markdown,+ implemented_at = excluded.implemented_at,+ implementation_thread_id = excluded.implementation_thread_id,created_at = excluded.created_at,updated_at = excluded.updated_at`,@@ -52,6 +58,8 @@ const makeProjectionThreadProposedPlanRepository = Effect.gen(function* () {thread_id AS "threadId",turn_id AS "turnId",plan_markdown AS "planMarkdown",+ implemented_at AS "implementedAt",+ implementation_thread_id AS "implementationThreadId",created_at AS "createdAt",updated_at AS "updatedAt"FROM projection_thread_proposed_plansdiff --git a/apps/server/src/persistence/Layers/ProjectionTurns.ts b/apps/server/src/persistence/Layers/ProjectionTurns.tsindex 8330661e3..72c6889c5 100644--- a/apps/server/src/persistence/Layers/ProjectionTurns.ts+++ b/apps/server/src/persistence/Layers/ProjectionTurns.ts@@ -106,6 +106,8 @@ const makeProjectionTurnRepository = Effect.gen(function* () {thread_id,turn_id,pending_message_id,+ source_proposed_plan_thread_id,+ source_proposed_plan_id,assistant_message_id,state,requested_at,@@ -120,6 +122,8 @@ const makeProjectionTurnRepository = Effect.gen(function* () {${row.threadId},NULL,${row.messageId},+ ${row.sourceProposedPlanThreadId},+ ${row.sourceProposedPlanId},NULL,'pending',${row.requestedAt},@@ -141,6 +145,8 @@ const makeProjectionTurnRepository = Effect.gen(function* () {SELECTthread_id AS "threadId",pending_message_id AS "messageId",+ source_proposed_plan_thread_id AS "sourceProposedPlanThreadId",+ source_proposed_plan_id AS "sourceProposedPlanId",requested_at AS "requestedAt"FROM projection_turnsWHERE thread_id = ${threadId}diff --git a/apps/server/src/persistence/Migrations.ts b/apps/server/src/persistence/Migrations.tsindex 7deb890dd..ea1821014 100644--- a/apps/server/src/persistence/Migrations.ts+++ b/apps/server/src/persistence/Migrations.ts@@ -25,6 +25,8 @@ import Migration0010 from "./Migrations/010_ProjectionThreadsRuntimeMode.ts";import Migration0011 from "./Migrations/011_OrchestrationThreadCreatedRuntimeMode.ts";import Migration0012 from "./Migrations/012_ProjectionThreadsInteractionMode.ts";import Migration0013 from "./Migrations/013_ProjectionThreadProposedPlans.ts";+import Migration0014 from "./Migrations/014_ProjectionThreadProposedPlanImplementation.ts";+import Migration0015 from "./Migrations/015_ProjectionTurnsSourceProposedPlan.ts";import { Effect } from "effect";/**@@ -51,6 +53,8 @@ const loader = Migrator.fromRecord({"11_OrchestrationThreadCreatedRuntimeMode": Migration0011,"12_ProjectionThreadsInteractionMode": Migration0012,"13_ProjectionThreadProposedPlans": Migration0013,+ "14_ProjectionThreadProposedPlanImplementation": Migration0014,+ "15_ProjectionTurnsSourceProposedPlan": Migration0015,});/**diff --git a/apps/server/src/persistence/Migrations/014_ProjectionThreadProposedPlanImplementation.ts b/apps/server/src/persistence/Migrations/014_ProjectionThreadProposedPlanImplementation.tsnew file mode 100644index 000000000..c7a82bfb3--- /dev/null+++ b/apps/server/src/persistence/Migrations/014_ProjectionThreadProposedPlanImplementation.ts@@ -0,0 +1,16 @@+import * as Effect from "effect/Effect";+import * as SqlClient from "effect/unstable/sql/SqlClient";++export default Effect.gen(function* () {+ const sql = yield* SqlClient.SqlClient;++ yield* sql`+ ALTER TABLE projection_thread_proposed_plans+ ADD COLUMN implemented_at TEXT+ `;++ yield* sql`+ ALTER TABLE projection_thread_proposed_plans+ ADD COLUMN implementation_thread_id TEXT+ `;+});diff --git a/apps/server/src/persistence/Migrations/015_ProjectionTurnsSourceProposedPlan.ts b/apps/server/src/persistence/Migrations/015_ProjectionTurnsSourceProposedPlan.tsnew file mode 100644index 000000000..57a266187--- /dev/null+++ b/apps/server/src/persistence/Migrations/015_ProjectionTurnsSourceProposedPlan.ts@@ -0,0 +1,16 @@+import * as Effect from "effect/Effect";+import * as SqlClient from "effect/unstable/sql/SqlClient";++export default Effect.gen(function* () {+ const sql = yield* SqlClient.SqlClient;++ yield* sql`+ ALTER TABLE projection_turns+ ADD COLUMN source_proposed_plan_thread_id TEXT+ `;++ yield* sql`+ ALTER TABLE projection_turns+ ADD COLUMN source_proposed_plan_id TEXT+ `;+});diff --git a/apps/server/src/persistence/Services/ProjectionThreadProposedPlans.ts b/apps/server/src/persistence/Services/ProjectionThreadProposedPlans.tsindex ee662d52b..d141a11bb 100644--- a/apps/server/src/persistence/Services/ProjectionThreadProposedPlans.ts+++ b/apps/server/src/persistence/Services/ProjectionThreadProposedPlans.ts@@ -15,6 +15,8 @@ export const ProjectionThreadProposedPlan = Schema.Struct({threadId: ThreadId,turnId: Schema.NullOr(TurnId),planMarkdown: TrimmedNonEmptyString,+ implementedAt: Schema.NullOr(IsoDateTime),+ implementationThreadId: Schema.NullOr(ThreadId),createdAt: IsoDateTime,updatedAt: IsoDateTime,});diff --git a/apps/server/src/persistence/Services/ProjectionTurns.ts b/apps/server/src/persistence/Services/ProjectionTurns.tsindex 1c791342f..b5888fdce 100644--- a/apps/server/src/persistence/Services/ProjectionTurns.ts+++ b/apps/server/src/persistence/Services/ProjectionTurns.ts@@ -11,6 +11,7 @@ import {IsoDateTime,MessageId,NonNegativeInt,+ OrchestrationProposedPlanId,OrchestrationCheckpointFile,OrchestrationCheckpointStatus,ThreadId,@@ -65,6 +66,8 @@ export type ProjectionTurnById = typeof ProjectionTurnById.Type;export const ProjectionPendingTurnStart = Schema.Struct({threadId: ThreadId,messageId: MessageId,+ sourceProposedPlanThreadId: Schema.NullOr(ThreadId),+ sourceProposedPlanId: Schema.NullOr(OrchestrationProposedPlanId),requestedAt: IsoDateTime,});export type ProjectionPendingTurnStart = typeof ProjectionPendingTurnStart.Type;diff --git a/apps/web/src/components/ChatView.browser.tsx b/apps/web/src/components/ChatView.browser.tsxindex 7b31dbdf3..6cbef09bd 100644--- a/apps/web/src/components/ChatView.browser.tsx+++ b/apps/web/src/components/ChatView.browser.tsx@@ -368,6 +368,8 @@ function createSnapshotWithLongProposedPlan(): OrchestrationReadModel {id: "plan-browser-test",turnId: null,planMarkdown,+ implementedAt: null,+ implementationThreadId: null,createdAt: isoAt(1_000),updatedAt: isoAt(1_001),},diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsxindex baba4b0cb..9ebb4ec9e 100644--- a/apps/web/src/components/ChatView.tsx+++ b/apps/web/src/components/ChatView.tsx@@ -55,6 +55,7 @@ import {deriveActivePlanState,findLatestProposedPlan,deriveWorkLogEntries,+ hasActionableProposedPlan,hasToolActivityForTurn,isLatestTurnSettled,formatElapsed,@@ -721,7 +722,7 @@ export default function ChatView({ threadId }: ChatViewProps) {pendingUserInputs.length === 0 &&interactionMode === "plan" &&latestTurnSettled &&- activeProposedPlan !== null;+ hasActionableProposedPlan(activeProposedPlan);const activePendingApproval = pendingApprovals[0] ?? null;const isComposerApprovalState = activePendingApproval !== null;const hasComposerHeader =@@ -2878,6 +2879,14 @@ export default function ChatView({ threadId }: ChatViewProps) {assistantDeliveryMode: settings.enableAssistantStreaming ? "streaming" : "buffered",runtimeMode,interactionMode: nextInteractionMode,+ ...(nextInteractionMode === "default" && activeProposedPlan+ ? {+ sourceProposedPlan: {+ threadId: activeThread.id,+ planId: activeProposedPlan.id,+ },+ }+ : {}),createdAt: messageCreatedAt,});// Optimistically open the plan sidebar when implementing (not refining).@@ -2902,6 +2911,7 @@ export default function ChatView({ threadId }: ChatViewProps) {},[activeThread,+ activeProposedPlan,beginSendPhase,forceStickToBottom,isConnecting,diff --git a/apps/web/src/components/Sidebar.logic.test.ts b/apps/web/src/components/Sidebar.logic.test.tsindex a8f84d564..8c3b47010 100644--- a/apps/web/src/components/Sidebar.logic.test.ts+++ b/apps/web/src/components/Sidebar.logic.test.ts@@ -141,6 +141,8 @@ describe("resolveThreadStatusPill", () => {createdAt: "2026-03-09T10:00:00.000Z",updatedAt: "2026-03-09T10:05:00.000Z",planMarkdown: "# Plan",+ implementedAt: null,+ implementationThreadId: null,},],session: {@@ -155,6 +157,35 @@ describe("resolveThreadStatusPill", () => {).toMatchObject({ label: "Plan Ready", pulse: false });});+ it("does not show plan ready after the proposed plan was implemented elsewhere", () => {+ expect(+ resolveThreadStatusPill({+ thread: {+ ...baseThread,+ latestTurn: makeLatestTurn(),+ proposedPlans: [+ {+ id: "plan-1" as never,+ turnId: "turn-1" as never,+ createdAt: "2026-03-09T10:00:00.000Z",+ updatedAt: "2026-03-09T10:05:00.000Z",+ planMarkdown: "# Plan",+ implementedAt: "2026-03-09T10:06:00.000Z",+ implementationThreadId: "thread-implement" as never,+ },+ ],+ session: {+ ...baseThread.session,+ status: "ready",+ orchestrationStatus: "ready",+ },+ },+ hasPendingApprovals: false,+ hasPendingUserInput: false,+ }),+ ).toMatchObject({ label: "Completed", pulse: false });+ });+it("shows completed when there is an unseen completion and no active blocker", () => {expect(resolveThreadStatusPill({diff --git a/apps/web/src/components/Sidebar.logic.ts b/apps/web/src/components/Sidebar.logic.tsindex d48873f7a..d9b394e4d 100644--- a/apps/web/src/components/Sidebar.logic.ts+++ b/apps/web/src/components/Sidebar.logic.ts@@ -1,6 +1,10 @@import type { Thread } from "../types";import { cn } from "../lib/utils";-import { findLatestProposedPlan, isLatestTurnSettled } from "../session-logic";+import {+ findLatestProposedPlan,+ hasActionableProposedPlan,+ isLatestTurnSettled,+} from "../session-logic";export const THREAD_SELECTION_SAFE_SELECTOR = "[data-thread-item], [data-thread-selection-safe]";export type SidebarNewThreadEnvMode = "local" | "worktree";@@ -124,7 +128,9 @@ export function resolveThreadStatusPill(input: {!hasPendingUserInput &&thread.interactionMode === "plan" &&isLatestTurnSettled(thread.latestTurn, thread.session) &&- findLatestProposedPlan(thread.proposedPlans, thread.latestTurn?.turnId ?? null) !== null;+ hasActionableProposedPlan(+ findLatestProposedPlan(thread.proposedPlans, thread.latestTurn?.turnId ?? null),+ );if (hasPlanReadyPrompt) {return {label: "Plan Ready",diff --git a/apps/web/src/session-logic.test.ts b/apps/web/src/session-logic.test.tsindex 74ba3a814..36c5b8619 100644--- a/apps/web/src/session-logic.test.ts+++ b/apps/web/src/session-logic.test.ts@@ -1,4 +1,10 @@-import { EventId, MessageId, TurnId, type OrchestrationThreadActivity } from "@t3tools/contracts";+import {+ EventId,+ MessageId,+ ThreadId,+ TurnId,+ type OrchestrationThreadActivity,+} from "@t3tools/contracts";import { describe, expect, it } from "vitest";import {@@ -10,6 +16,7 @@ import {deriveTimelineEntries,deriveWorkLogEntries,findLatestProposedPlan,+ hasActionableProposedPlan,hasToolActivityForTurn,isLatestTurnSettled,} from "./session-logic";@@ -269,6 +276,8 @@ describe("findLatestProposedPlan", () => {id: "plan:thread-1:turn:turn-1",turnId: TurnId.makeUnsafe("turn-1"),planMarkdown: "# Older",+ implementedAt: null,+ implementationThreadId: null,createdAt: "2026-02-23T00:00:01.000Z",updatedAt: "2026-02-23T00:00:01.000Z",},@@ -276,6 +285,8 @@ describe("findLatestProposedPlan", () => {id: "plan:thread-1:turn:turn-1",turnId: TurnId.makeUnsafe("turn-1"),planMarkdown: "# Latest",+ implementedAt: null,+ implementationThreadId: null,createdAt: "2026-02-23T00:00:01.000Z",updatedAt: "2026-02-23T00:00:02.000Z",},@@ -283,6 +294,8 @@ describe("findLatestProposedPlan", () => {id: "plan:thread-1:turn:turn-2",turnId: TurnId.makeUnsafe("turn-2"),planMarkdown: "# Different turn",+ implementedAt: null,+ implementationThreadId: null,createdAt: "2026-02-23T00:00:03.000Z",updatedAt: "2026-02-23T00:00:03.000Z",},@@ -293,6 +306,8 @@ describe("findLatestProposedPlan", () => {id: "plan:thread-1:turn:turn-1",turnId: "turn-1",planMarkdown: "# Latest",+ implementedAt: null,+ implementationThreadId: null,createdAt: "2026-02-23T00:00:01.000Z",updatedAt: "2026-02-23T00:00:02.000Z",});@@ -305,6 +320,8 @@ describe("findLatestProposedPlan", () => {id: "plan:thread-1:turn:turn-1",turnId: TurnId.makeUnsafe("turn-1"),planMarkdown: "# First",+ implementedAt: null,+ implementationThreadId: null,createdAt: "2026-02-23T00:00:01.000Z",updatedAt: "2026-02-23T00:00:01.000Z",},@@ -312,6 +329,8 @@ describe("findLatestProposedPlan", () => {id: "plan:thread-1:turn:turn-2",turnId: TurnId.makeUnsafe("turn-2"),planMarkdown: "# Latest",+ implementedAt: null,+ implementationThreadId: null,createdAt: "2026-02-23T00:00:02.000Z",updatedAt: "2026-02-23T00:00:03.000Z",},@@ -323,6 +342,36 @@ describe("findLatestProposedPlan", () => {});});+describe("hasActionableProposedPlan", () => {+ it("returns true for an unimplemented proposed plan", () => {+ expect(+ hasActionableProposedPlan({+ id: "plan-1",+ turnId: TurnId.makeUnsafe("turn-1"),+ planMarkdown: "# Plan",+ implementedAt: null,+ implementationThreadId: null,+ createdAt: "2026-02-23T00:00:00.000Z",+ updatedAt: "2026-02-23T00:00:01.000Z",+ }),+ ).toBe(true);+ });++ it("returns false for a proposed plan already implemented elsewhere", () => {+ expect(+ hasActionableProposedPlan({+ id: "plan-1",+ turnId: TurnId.makeUnsafe("turn-1"),+ planMarkdown: "# Plan",+ implementedAt: "2026-02-23T00:00:02.000Z",+ implementationThreadId: ThreadId.makeUnsafe("thread-implement"),+ createdAt: "2026-02-23T00:00:00.000Z",+ updatedAt: "2026-02-23T00:00:02.000Z",+ }),+ ).toBe(false);+ });+});+describe("deriveWorkLogEntries", () => {it("omits tool started entries and keeps completed entries", () => {const activities: OrchestrationThreadActivity[] = [@@ -531,6 +580,8 @@ describe("deriveTimelineEntries", () => {id: "plan:thread-1:turn:turn-1",turnId: TurnId.makeUnsafe("turn-1"),planMarkdown: "# Ship it",+ implementedAt: null,+ implementationThreadId: null,createdAt: "2026-02-23T00:00:02.000Z",updatedAt: "2026-02-23T00:00:02.000Z",},@@ -550,6 +601,8 @@ describe("deriveTimelineEntries", () => {kind: "proposed-plan",proposedPlan: {planMarkdown: "# Ship it",+ implementedAt: null,+ implementationThreadId: null,},});});diff --git a/apps/web/src/session-logic.ts b/apps/web/src/session-logic.tsindex e389f10e2..02042acd9 100644--- a/apps/web/src/session-logic.ts+++ b/apps/web/src/session-logic.ts@@ -7,6 +7,7 @@ import {type ProviderKind,type ToolLifecycleItemType,type UserInputQuestion,+ type ThreadId,type TurnId,} from "@t3tools/contracts";@@ -72,6 +73,8 @@ export interface LatestProposedPlanState {updatedAt: string;turnId: TurnId | null;planMarkdown: string;+ implementedAt: string | null;+ implementationThreadId: ThreadId | null;}export type TimelineEntry =@@ -380,6 +383,8 @@ export function findLatestProposedPlan(updatedAt: matchingTurnPlan.updatedAt,turnId: matchingTurnPlan.turnId,planMarkdown: matchingTurnPlan.planMarkdown,+ implementedAt: matchingTurnPlan.implementedAt,+ implementationThreadId: matchingTurnPlan.implementationThreadId,};}}@@ -400,9 +405,17 @@ export function findLatestProposedPlan(updatedAt: latestPlan.updatedAt,turnId: latestPlan.turnId,planMarkdown: latestPlan.planMarkdown,+ implementedAt: latestPlan.implementedAt,+ implementationThreadId: latestPlan.implementationThreadId,};}+export function hasActionableProposedPlan(+ proposedPlan: LatestProposedPlanState | Pick<ProposedPlan, "implementedAt"> | null,+): boolean {+ return proposedPlan !== null && proposedPlan.implementedAt === null;+}+export function deriveWorkLogEntries(activities: ReadonlyArray<OrchestrationThreadActivity>,latestTurnId: TurnId | undefined,diff --git a/apps/web/src/store.ts b/apps/web/src/store.tsindex faebe4b0f..73f113313 100644--- a/apps/web/src/store.ts+++ b/apps/web/src/store.ts@@ -304,6 +304,8 @@ export function syncServerReadModel(state: AppState, readModel: OrchestrationReaid: proposedPlan.id,turnId: proposedPlan.turnId,planMarkdown: proposedPlan.planMarkdown,+ implementedAt: proposedPlan.implementedAt,+ implementationThreadId: proposedPlan.implementationThreadId,createdAt: proposedPlan.createdAt,updatedAt: proposedPlan.updatedAt,})),diff --git a/apps/web/src/types.ts b/apps/web/src/types.tsindex c071fb3f6..32a7fe02b 100644--- a/apps/web/src/types.ts+++ b/apps/web/src/types.ts@@ -53,6 +53,8 @@ export interface ProposedPlan {id: OrchestrationProposedPlanId;turnId: TurnId | null;planMarkdown: string;+ implementedAt: string | null;+ implementationThreadId: ThreadId | null;createdAt: string;updatedAt: string;}diff --git a/packages/contracts/src/orchestration.test.ts b/packages/contracts/src/orchestration.test.tsindex 25a641edb..136c5a849 100644--- a/packages/contracts/src/orchestration.test.ts+++ b/packages/contracts/src/orchestration.test.ts@@ -6,6 +6,7 @@ import {DEFAULT_PROVIDER_INTERACTION_MODE,DEFAULT_RUNTIME_MODE,OrchestrationGetTurnDiffInput,+ OrchestrationProposedPlan,OrchestrationSession,ProjectCreateCommand,ThreadTurnStartCommand,@@ -21,6 +22,7 @@ const decodeThreadTurnStartCommand = Schema.decodeUnknownEffect(ThreadTurnStartCconst decodeThreadTurnStartRequestedPayload = Schema.decodeUnknownEffect(ThreadTurnStartRequestedPayload,);+const decodeOrchestrationProposedPlan = Schema.decodeUnknownEffect(OrchestrationProposedPlan);const decodeOrchestrationSession = Schema.decodeUnknownEffect(OrchestrationSession);const decodeThreadCreatedPayload = Schema.decodeUnknownEffect(ThreadCreatedPayload);@@ -186,6 +188,31 @@ it.effect("accepts provider-scoped model options in thread.turn.start", () =>}),);+it.effect("accepts a source proposed plan reference in thread.turn.start", () =>+ Effect.gen(function* () {+ const parsed = yield* decodeThreadTurnStartCommand({+ type: "thread.turn.start",+ commandId: "cmd-turn-source-plan",+ threadId: "thread-2",+ message: {+ messageId: "msg-source-plan",+ role: "user",+ text: "implement this",+ attachments: [],+ },+ sourceProposedPlan: {+ threadId: "thread-1",+ planId: "plan-1",+ },+ createdAt: "2026-01-01T00:00:00.000Z",+ });+ assert.deepStrictEqual(parsed.sourceProposedPlan, {+ threadId: "thread-1",+ planId: "plan-1",+ });+ }),+);+it.effect("decodes thread.turn-start-requested defaults for provider, runtime mode, and interaction mode",() =>@@ -198,9 +225,28 @@ it.effect(assert.strictEqual(parsed.provider, undefined);assert.strictEqual(parsed.runtimeMode, DEFAULT_RUNTIME_MODE);assert.strictEqual(parsed.interactionMode, DEFAULT_PROVIDER_INTERACTION_MODE);+ assert.strictEqual(parsed.sourceProposedPlan, undefined);}),);+it.effect("decodes thread.turn-start-requested source proposed plan metadata when present", () =>+ Effect.gen(function* () {+ const parsed = yield* decodeThreadTurnStartRequestedPayload({+ threadId: "thread-2",+ messageId: "msg-2",+ sourceProposedPlan: {+ threadId: "thread-1",+ planId: "plan-1",+ },+ createdAt: "2026-01-01T00:00:00.000Z",+ });+ assert.deepStrictEqual(parsed.sourceProposedPlan, {+ threadId: "thread-1",+ planId: "plan-1",+ });+ }),+);+it.effect("decodes orchestration session runtime mode defaults", () =>Effect.gen(function* () {const parsed = yield* decodeOrchestrationSession({@@ -216,3 +262,33 @@ it.effect("decodes orchestration session runtime mode defaults", () =>assert.strictEqual(parsed.runtimeMode, DEFAULT_RUNTIME_MODE);}),);++it.effect("defaults proposed plan implementation metadata for historical rows", () =>+ Effect.gen(function* () {+ const parsed = yield* decodeOrchestrationProposedPlan({+ id: "plan-1",+ turnId: "turn-1",+ planMarkdown: "# Plan",+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+ });+ assert.strictEqual(parsed.implementedAt, null);+ assert.strictEqual(parsed.implementationThreadId, null);+ }),+);++it.effect("preserves proposed plan implementation metadata when present", () =>+ Effect.gen(function* () {+ const parsed = yield* decodeOrchestrationProposedPlan({+ id: "plan-2",+ turnId: "turn-2",+ planMarkdown: "# Plan",+ implementedAt: "2026-01-02T00:00:00.000Z",+ implementationThreadId: "thread-2",+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-02T00:00:00.000Z",+ });+ assert.strictEqual(parsed.implementedAt, "2026-01-02T00:00:00.000Z");+ assert.strictEqual(parsed.implementationThreadId, "thread-2");+ }),+);diff --git a/packages/contracts/src/orchestration.ts b/packages/contracts/src/orchestration.tsindex 17c5eb21d..4ee53c276 100644--- a/packages/contracts/src/orchestration.ts+++ b/packages/contracts/src/orchestration.ts@@ -163,11 +163,18 @@ export const OrchestrationProposedPlan = Schema.Struct({id: OrchestrationProposedPlanId,turnId: Schema.NullOr(TurnId),planMarkdown: TrimmedNonEmptyString,+ implementedAt: Schema.NullOr(IsoDateTime).pipe(Schema.withDecodingDefault(() => null)),+ implementationThreadId: Schema.NullOr(ThreadId).pipe(Schema.withDecodingDefault(() => null)),createdAt: IsoDateTime,updatedAt: IsoDateTime,});export type OrchestrationProposedPlan = typeof OrchestrationProposedPlan.Type;+const SourceProposedPlanReference = Schema.Struct({+ threadId: ThreadId,+ planId: OrchestrationProposedPlanId,+});+export const OrchestrationSessionStatus = Schema.Literals(["idle","starting",@@ -374,6 +381,7 @@ export const ThreadTurnStartCommand = Schema.Struct({interactionMode: ProviderInteractionMode.pipe(Schema.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE),),+ sourceProposedPlan: Schema.optional(SourceProposedPlanReference),createdAt: IsoDateTime,});@@ -394,6 +402,7 @@ const ClientThreadTurnStartCommand = Schema.Struct({assistantDeliveryMode: Schema.optional(AssistantDeliveryMode),runtimeMode: RuntimeMode,interactionMode: ProviderInteractionMode,+ sourceProposedPlan: Schema.optional(SourceProposedPlanReference),createdAt: IsoDateTime,});@@ -676,6 +685,7 @@ export const ThreadTurnStartRequestedPayload = Schema.Struct({interactionMode: ProviderInteractionMode.pipe(Schema.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE),),+ sourceProposedPlan: Schema.optional(SourceProposedPlanReference),createdAt: IsoDateTime,});