fix(server): show Implement button more reliably for Claude plan mode

apps/server/src/orchestration/Layers/ProjectionPipeline.ts

@@ -683,6 +683,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 
         case "thread.message-sent":
         case "thread.proposed-plan-upserted":
+        case "thread.proposed-plan-removed":
         case "thread.activity-appended":
         case "thread.approval-response-requested":
         case "thread.user-input-response-requested": {
@@ -871,6 +872,12 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
           });
           return;
 
+        case "thread.proposed-plan-removed":
+          yield* projectionThreadProposedPlanRepository.deleteByPlanId({
+            planId: event.payload.planId,
+          });
+          return;
+
         case "thread.reverted": {
           const existingRows = yield* projectionThreadProposedPlanRepository.listByThreadId({
             threadId: event.payload.threadId,

apps/server/src/orchestration/Schemas.ts

@@ -11,6 +11,7 @@ import {
   ThreadUnarchivedPayload as ContractsThreadUnarchivedPayloadSchema,
   ThreadMessageSentPayload as ContractsThreadMessageSentPayloadSchema,
   ThreadProposedPlanUpsertedPayload as ContractsThreadProposedPlanUpsertedPayloadSchema,
+  ThreadProposedPlanRemovedPayload as ContractsThreadProposedPlanRemovedPayloadSchema,
   ThreadSessionSetPayload as ContractsThreadSessionSetPayloadSchema,
   ThreadTurnDiffCompletedPayload as ContractsThreadTurnDiffCompletedPayloadSchema,
   ThreadRevertedPayload as ContractsThreadRevertedPayloadSchema,
@@ -37,6 +38,7 @@ export const ThreadUnarchivedPayload = ContractsThreadUnarchivedPayloadSchema;
 
 export const MessageSentPayloadSchema = ContractsThreadMessageSentPayloadSchema;
 export const ThreadProposedPlanUpsertedPayload = ContractsThreadProposedPlanUpsertedPayloadSchema;
+export const ThreadProposedPlanRemovedPayload = ContractsThreadProposedPlanRemovedPayloadSchema;
 export const ThreadSessionSetPayload = ContractsThreadSessionSetPayloadSchema;
 export const ThreadTurnDiffCompletedPayload = ContractsThreadTurnDiffCompletedPayloadSchema;
 export const ThreadRevertedPayload = ContractsThreadRevertedPayloadSchema;

apps/server/src/orchestration/decider.ts

@@ -653,6 +653,85 @@ export const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand"
       };
     }
 
+    case "thread.proposed-plan.promote": {
+      const thread = yield* requireThread({
+        readModel,
+        command,
+        threadId: command.threadId,
+      });
+      const message = thread.messages.find((entry) => entry.id === command.messageId);
+      if (!message) {
+        return yield* new OrchestrationCommandInvariantError({
+          commandType: command.type,
+          detail: `Message '${command.messageId}' not found in thread '${command.threadId}'.`,
+        });
+      }
+      if (message.role !== "assistant") {
+        return yield* new OrchestrationCommandInvariantError({
+          commandType: command.type,
+          detail: `Message '${command.messageId}' is not an assistant message.`,
+        });
+      }
+      const planMarkdown = message.text.trim();
+      if (planMarkdown.length === 0) {
+        return yield* new OrchestrationCommandInvariantError({
+          commandType: command.type,
+          detail: `Message '${command.messageId}' has no text to promote.`,
+        });
+      }
+      const planId = `plan:${command.threadId}:promoted:${command.messageId}`;
+      const existingPlan = thread.proposedPlans.find((entry) => entry.id === planId);
+      return {
+        ...withEventBase({
+          aggregateKind: "thread",
+          aggregateId: command.threadId,
+          occurredAt: command.createdAt,
+          commandId: command.commandId,
+        }),
+        type: "thread.proposed-plan-upserted",
+        payload: {
+          threadId: command.threadId,
+          proposedPlan: {
+            id: planId,
+            turnId: message.turnId ?? null,
+            planMarkdown,
+            implementedAt: existingPlan?.implementedAt ?? null,
+            implementationThreadId: existingPlan?.implementationThreadId ?? null,
+            createdAt: existingPlan?.createdAt ?? command.createdAt,
+            updatedAt: command.createdAt,
+          },
+        },
+      };
+    }
+
+    case "thread.proposed-plan.revert": {
+      const thread = yield* requireThread({
+        readModel,
+        command,
+        threadId: command.threadId,
+      });
+      const existingPlan = thread.proposedPlans.find((entry) => entry.id === command.planId);
+      if (!existingPlan) {
+        return yield* new OrchestrationCommandInvariantError({
+          commandType: command.type,
+          detail: `Proposed plan '${command.planId}' not found in thread '${command.threadId}'.`,
+        });
+      }
+      return {
+        ...withEventBase({
+          aggregateKind: "thread",
+          aggregateId: command.threadId,
+          occurredAt: command.createdAt,
+          commandId: command.commandId,
+        }),
+        type: "thread.proposed-plan-removed",
+        payload: {
+          threadId: command.threadId,
+          planId: command.planId,
+        },
+      };
+    }
+
     case "thread.turn.diff.complete": {
       yield* requireThread({
         readModel,

apps/server/src/orchestration/projector.ts

@@ -20,6 +20,7 @@ import {
   ThreadInteractionModeSetPayload,
   ThreadMetaUpdatedPayload,
   ThreadProposedPlanUpsertedPayload,
+  ThreadProposedPlanRemovedPayload,
   ThreadRuntimeModeSetPayload,
   ThreadUnarchivedPayload,
   ThreadRevertedPayload,
@@ -499,6 +500,31 @@ export function projectEvent(
         };
       });
 
+    case "thread.proposed-plan-removed":
+      return Effect.gen(function* () {
+        const payload = yield* decodeForEvent(
+          ThreadProposedPlanRemovedPayload,
+          event.payload,
+          event.type,
+          "payload",
+        );
+        const thread = nextBase.threads.find((entry) => entry.id === payload.threadId);
+        if (!thread) {
+          return nextBase;
+        }
+        const proposedPlans = thread.proposedPlans.filter((entry) => entry.id !== payload.planId);
+        if (proposedPlans.length === thread.proposedPlans.length) {
+          return nextBase;
+        }
+        return {
+          ...nextBase,
+          threads: updateThread(nextBase.threads, payload.threadId, {
+            proposedPlans,
+            updatedAt: event.occurredAt,
+          }),
+        };
+      });
+
     case "thread.turn-diff-completed":
       return Effect.gen(function* () {
         const payload = yield* decodeForEvent(

apps/server/src/persistence/Layers/ProjectionThreadProposedPlans.ts

@@ -4,6 +4,7 @@ import * as SqlSchema from "effect/unstable/sql/SqlSchema";
 
 import { toPersistenceSqlError } from "../Errors.ts";
 import {
+  DeleteProjectionThreadProposedPlanByIdInput,
   DeleteProjectionThreadProposedPlansInput,
   ListProjectionThreadProposedPlansInput,
   ProjectionThreadProposedPlan,
@@ -76,6 +77,14 @@ const makeProjectionThreadProposedPlanRepository = Effect.gen(function* () {
     `,
   });
 
+  const deleteProjectionThreadProposedPlanRowById = SqlSchema.void({
+    Request: DeleteProjectionThreadProposedPlanByIdInput,
+    execute: ({ planId }) => sql`
+      DELETE FROM projection_thread_proposed_plans
+      WHERE plan_id = ${planId}
+    `,
+  });
+
   const upsert: ProjectionThreadProposedPlanRepositoryShape["upsert"] = (row) =>
     upsertProjectionThreadProposedPlanRow(row).pipe(
       Effect.mapError(toPersistenceSqlError("ProjectionThreadProposedPlanRepository.upsert:query")),
@@ -97,10 +106,18 @@ const makeProjectionThreadProposedPlanRepository = Effect.gen(function* () {
       ),
     );
 
+  const deleteByPlanId: ProjectionThreadProposedPlanRepositoryShape["deleteByPlanId"] = (input) =>
+    deleteProjectionThreadProposedPlanRowById(input).pipe(
+      Effect.mapError(
+        toPersistenceSqlError("ProjectionThreadProposedPlanRepository.deleteByPlanId:query"),
+      ),
+    );
+
   return {
     upsert,
     listByThreadId,
     deleteByThreadId,
+    deleteByPlanId,
   } satisfies ProjectionThreadProposedPlanRepositoryShape;
 });
 

apps/server/src/persistence/Services/ProjectionThreadProposedPlans.ts

@@ -34,6 +34,12 @@ export const DeleteProjectionThreadProposedPlansInput = Schema.Struct({
 export type DeleteProjectionThreadProposedPlansInput =
   typeof DeleteProjectionThreadProposedPlansInput.Type;
 
+export const DeleteProjectionThreadProposedPlanByIdInput = Schema.Struct({
+  planId: OrchestrationProposedPlanId,
+});
+export type DeleteProjectionThreadProposedPlanByIdInput =
+  typeof DeleteProjectionThreadProposedPlanByIdInput.Type;
+
 export interface ProjectionThreadProposedPlanRepositoryShape {
   readonly upsert: (
     proposedPlan: ProjectionThreadProposedPlan,
@@ -44,6 +50,9 @@ export interface ProjectionThreadProposedPlanRepositoryShape {
   readonly deleteByThreadId: (
     input: DeleteProjectionThreadProposedPlansInput,
   ) => Effect.Effect<void, ProjectionRepositoryError>;
+  readonly deleteByPlanId: (
+    input: DeleteProjectionThreadProposedPlanByIdInput,
+  ) => Effect.Effect<void, ProjectionRepositoryError>;
 }
 
 export class ProjectionThreadProposedPlanRepository extends Context.Service<

apps/server/src/provider/Layers/ClaudeAdapter.ts

@@ -117,6 +117,7 @@ interface ClaudeTurnState {
   readonly assistantTextBlocks: Map<number, AssistantTextBlockState>;
   readonly assistantTextBlockOrder: Array<AssistantTextBlockState>;
   readonly capturedProposedPlanKeys: Set<string>;
+  readonly interactionMode: "plan" | "default";
   nextSyntheticAssistantBlockIndex: number;
 }
 
@@ -173,6 +174,7 @@ interface ClaudeSessionContext {
   lastKnownTokenUsage: ThreadTokenUsageSnapshot | undefined;
   lastAssistantUuid: string | undefined;
   lastThreadStartedId: string | undefined;
+  currentInteractionMode: "plan" | "default";
   stopped: boolean;
 }
 
@@ -1359,7 +1361,10 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
     input: {
       readonly planMarkdown: string;
       readonly toolUseId?: string | undefined;
-      readonly rawSource: "claude.sdk.message" | "claude.sdk.permission";
+      readonly rawSource:
+        | "claude.sdk.message"
+        | "claude.sdk.permission"
+        | "client.user-promoted";
       readonly rawMethod: string;
       readonly rawPayload: unknown;
     },
@@ -1956,6 +1961,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
         assistantTextBlocks: new Map(),
         assistantTextBlockOrder: [],
         capturedProposedPlanKeys: new Set(),
+        interactionMode: context.currentInteractionMode,
         nextSyntheticAssistantBlockIndex: -1,
       };
       context.session = {
@@ -2973,6 +2979,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
         lastKnownTokenUsage: undefined,
         lastAssistantUuid: resumeState?.resumeSessionAt,
         lastThreadStartedId: undefined,
+        currentInteractionMode: permissionMode === "plan" ? "plan" : "default",
         stopped: false,
       };
       yield* Ref.set(contextRef, context);
@@ -3085,21 +3092,25 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
         try: () => context.query.setPermissionMode("plan"),
         catch: (cause) => toRequestError(input.threadId, "turn/setPermissionMode", cause),
       });
+      context.currentInteractionMode = "plan";
     } else if (input.interactionMode === "default") {
       yield* Effect.tryPromise({
         try: () => context.query.setPermissionMode(context.basePermissionMode ?? "default"),
         catch: (cause) => toRequestError(input.threadId, "turn/setPermissionMode", cause),
       });
+      context.currentInteractionMode = "default";
     }
 
     const turnId = TurnId.make(yield* Random.nextUUIDv4);
+    const resolvedInteractionMode = context.currentInteractionMode;
     const turnState: ClaudeTurnState = {
       turnId,
       startedAt: yield* nowIso,
       items: [],
       assistantTextBlocks: new Map(),
       assistantTextBlockOrder: [],
       capturedProposedPlanKeys: new Set(),
+      interactionMode: resolvedInteractionMode,
       nextSyntheticAssistantBlockIndex: -1,
     };
 

apps/server/src/ws.ts

@@ -84,6 +84,7 @@ function isThreadDetailEvent(event: OrchestrationEvent): event is Extract<
     type:
       | "thread.message-sent"
       | "thread.proposed-plan-upserted"
+      | "thread.proposed-plan-removed"
       | "thread.activity-appended"
       | "thread.turn-diff-completed"
       | "thread.reverted"
@@ -93,6 +94,7 @@ function isThreadDetailEvent(event: OrchestrationEvent): event is Extract<
   return (
     event.type === "thread.message-sent" ||
     event.type === "thread.proposed-plan-upserted" ||
+    event.type === "thread.proposed-plan-removed" ||
     event.type === "thread.activity-appended" ||
     event.type === "thread.turn-diff-completed" ||
     event.type === "thread.reverted" ||