fix(ui): restore green build (monaco 0.55 pin + dead css import)

apps/daemon/src/host/acp-provider-execution.ts

@@ -29,6 +29,12 @@ import type { AcpConfigState, AcpAgentDiagnostics, AcpDebugRequest, AcpDebugRunR
 
 const ACP_PROVIDER_ID = "acp";
 
+const normalizePlanStatus = (status: unknown): "pending" | "in_progress" | "completed" => {
+  if (status === "completed" || status === "done") return "completed";
+  if (status === "in_progress") return "in_progress";
+  return "pending";
+};
+
 type PendingAcpPermission = {
   sessionId: string;
   toolCallId: string;
@@ -47,7 +53,16 @@ type PendingAcpPermission = {
  */
 export class AcpProviderExecutionPort implements ProviderExecutionPort {
   private runtimePromise: Promise<AcpRuntime> | null = null;
-  private activeTurns = new Map<string, { controller: AbortController; eventId: string; runId: string }>();
+  private activeTurns = new Map<
+    string,
+    {
+      controller: AbortController;
+      eventId: string;
+      runId: string;
+      donePromise: Promise<void>;
+      doneResolve: () => void;
+    }
+  >();
   private pendingPermissions = new Map<string, PendingAcpPermission>();
   private readonly contentMapper = new AcpContentMapper();
 
@@ -138,10 +153,16 @@ export class AcpProviderExecutionPort implements ProviderExecutionPort {
     const runtime = await this.getRuntime();
     const record = await this.getSessionRecord(sessionId);
     const controller = new AbortController();
+    let doneResolve!: () => void;
+    const donePromise = new Promise<void>((resolve) => {
+      doneResolve = resolve;
+    });
     this.activeTurns.set(sessionId, {
       controller,
       eventId: assistantMessageId,
       runId: requestId,
+      donePromise,
+      doneResolve,
     });
 
     void this.runTurn(
@@ -154,7 +175,11 @@ export class AcpProviderExecutionPort implements ProviderExecutionPort {
       assistantMessageId,
       record?.workdir,
     ).finally(() => {
-      this.activeTurns.delete(sessionId);
+      const current = this.activeTurns.get(sessionId);
+      if (current && current.runId === requestId) {
+        this.activeTurns.delete(sessionId);
+      }
+      doneResolve();
     });
 
     return { requestId, messageId: assistantMessageId };
@@ -374,6 +399,7 @@ export class AcpProviderExecutionPort implements ProviderExecutionPort {
     workdir?: string,
   ): Promise<void> {
     const blocks: Array<Record<string, unknown>> = [];
+    let planRevision = 0;
     try {
       for await (const notification of runtime.runPromptTurn({
         conversationId: sessionId,
@@ -385,8 +411,26 @@ export class AcpProviderExecutionPort implements ProviderExecutionPort {
         if (controller.signal.aborted) break;
 
         const mapped = this.contentMapper.map(notification);
+
+        if (mapped.planEntries && mapped.planEntries.length > 0) {
+          planRevision += 1;
+          const plan = mapped.planEntries
+            .map((entry) => ({ step: (entry.content ?? "").trim(), status: normalizePlanStatus(entry.status) }))
+            .filter((item) => item.step.length > 0);
+          if (plan.length > 0) {
+            this.eventPublisher.publish("chat.plan.updated", {
+              sessionId,
+              messageId: assistantMessageId,
+              plan,
+              revision: planRevision,
+              updatedAt: new Date().toISOString(),
+            });
+          }
+        }
+
         const now = Date.now();
         for (const block of mapped.blocks) {
+          if (block.type === "plan") continue;
           const last = blocks.at(-1);
           if (block.type === "content" && last?.type === "content") {
             last.content = `${last.content ?? ""}${block.content ?? ""}`;
@@ -498,9 +542,43 @@ export class AcpProviderExecutionPort implements ProviderExecutionPort {
     });
   }
 
-  async steerActiveTurn(_sessionId: string, _content: string | SendMessageInput): Promise<void> {
-    await this.cancelGeneration(_sessionId);
-    await this.sendMessage(_sessionId, _content);
+  async steerActiveTurn(sessionId: string, content: string | SendMessageInput): Promise<void> {
+    await this.interruptActiveTurn(sessionId);
+    await this.sendMessage(sessionId, content);
+  }
+
+  /**
+   * Non-destructively interrupts the in-flight ACP prompt for a session so a new
+   * turn can follow (used by steer). Unlike {@link cancelGeneration}, this does
+   * NOT tear down the session or unbind the agent process: it asks the agent to
+   * cancel the active `session/prompt` request, aborts local streaming, and
+   * waits for the turn to settle before returning.
+   */
+  private async interruptActiveTurn(sessionId: string): Promise<void> {
+    const active = this.activeTurns.get(sessionId);
+    if (!active) return;
+
+    active.controller.abort();
+
+    for (const [toolCallId, pending] of this.pendingPermissions) {
+      if (pending.sessionId !== sessionId) continue;
+      this.pendingPermissions.delete(toolCallId);
+      pending.resolve({ outcome: { outcome: "cancelled" } });
+    }
+
+    try {
+      const runtime = await this.getRuntime();
+      const session = runtime.sessionManager.getSession(sessionId);
+      if (session) {
+        await session.connection.agent.notify(acpMethods.agent.session.cancel, {
+          sessionId: session.sessionId,
+        } as schema.CancelNotification);
+      }
+    } catch (error) {
+      console.warn("[ACP] Failed to send session/cancel for steer:", error);
+    }
+
+    await Promise.race([active.donePromise, new Promise<void>((resolve) => setTimeout(resolve, 4000))]).catch(() => {});
   }
 
   async getAcpSessionCommands(conversationId: string): Promise<

apps/daemon/test/acpProviderExecution.test.ts

@@ -32,13 +32,19 @@ describe("AcpProviderExecutionPort", () => {
   });
 
   it("publishes and persists decoded ACP assistant text chunks", async () => {
-    const addMessage = vi.fn(async () => "persisted-assistant-1");
+    const finalizeAssistantMessage = vi.fn(async () => undefined);
+    const setMessageError = vi.fn(async () => undefined);
     const publish = vi.fn();
-    const port = new AcpProviderExecutionPort({} as never, { addMessage } as never, { publish } as never, {
-      dataDir: "/tmp",
-      appVersion: "1.0.0",
-      db: { prepare: vi.fn() },
-    });
+    const port = new AcpProviderExecutionPort(
+      {} as never,
+      { finalizeAssistantMessage, setMessageError } as never,
+      { publish } as never,
+      {
+        dataDir: "/tmp",
+        appVersion: "1.0.0",
+        db: { prepare: vi.fn() },
+      },
+    );
     const runtime = {
       async *runPromptTurn() {
         yield {
@@ -96,15 +102,91 @@ describe("AcpProviderExecutionPort", () => {
       expect.objectContaining({
         requestId: "request-1",
         sessionId: "conversation-1",
-        messageId: "persisted-assistant-1",
+        messageId: "assistant-1",
         blocks: expect.arrayContaining([
           expect.objectContaining({ content: "OpenCode", status: "success" }),
           expect.objectContaining({ type: "reasoning_content", content: "The user" }),
           expect.objectContaining({ type: "tool_call", tool_call: expect.objectContaining({ id: "tool-1" }) }),
         ]),
       }),
     );
-    expect(addMessage).toHaveBeenCalledWith("conversation-1", "assistant", expect.stringContaining("OpenCode"));
+    expect(finalizeAssistantMessage).toHaveBeenCalledWith(
+      "assistant-1",
+      expect.arrayContaining([expect.objectContaining({ content: "OpenCode", status: "success" })]),
+      expect.any(String),
+    );
+    expect(setMessageError).not.toHaveBeenCalled();
+  });
+
+  it("routes ACP plan updates to the plan widget and skips inline plan blocks", async () => {
+    const finalizeAssistantMessage = vi.fn(async () => undefined);
+    const setMessageError = vi.fn(async () => undefined);
+    const publish = vi.fn();
+    const port = new AcpProviderExecutionPort(
+      {} as never,
+      { finalizeAssistantMessage, setMessageError } as never,
+      { publish } as never,
+      {
+        dataDir: "/tmp",
+        appVersion: "1.0.0",
+        db: { prepare: vi.fn() },
+      },
+    );
+    const runtime = {
+      async *runPromptTurn() {
+        yield {
+          sessionId: "acp-session",
+          update: {
+            sessionUpdate: "plan",
+            entries: [
+              { content: "Analyze", status: "completed" },
+              { content: "Implement", status: "in_progress" },
+              { content: "Test", status: "pending" },
+            ],
+          },
+        };
+        yield {
+          sessionId: "acp-session",
+          update: {
+            sessionUpdate: "plan",
+            entries: [
+              { content: "Analyze", status: "completed" },
+              { content: "Implement", status: "completed" },
+              { content: "Test", status: "in_progress" },
+            ],
+          },
+        };
+      },
+    };
+
+    await (port as any).runTurn(
+      runtime,
+      "conversation-1",
+      { id: "opencode", name: "OpenCode" },
+      [{ type: "text", text: "hello" }],
+      new AbortController(),
+      "request-1",
+      "assistant-1",
+    );
+
+    const planCalls = publish.mock.calls.filter((call) => call[0] === "chat.plan.updated");
+    expect(planCalls).toHaveLength(2);
+    expect(planCalls[0][1]).toMatchObject({
+      sessionId: "conversation-1",
+      messageId: "assistant-1",
+      revision: 1,
+      plan: [
+        { step: "Analyze", status: "completed" },
+        { step: "Implement", status: "in_progress" },
+        { step: "Test", status: "pending" },
+      ],
+    });
+    expect(planCalls[1][1]).toMatchObject({ revision: 2 });
+
+    for (const call of publish.mock.calls) {
+      if (call[0] !== "chat.stream.updated") continue;
+      expect((call[1] as { blocks: Array<{ type: string }> }).blocks.some((b) => b.type === "plan")).toBe(false);
+    }
   });
 
   it("allows ACP tool permissions once in full access mode", async () => {
@@ -213,16 +295,11 @@ describe("AcpProviderExecutionPort", () => {
   });
 
   it("times out a hanging permission resolver with a cancelled outcome", async () => {
-    vi.useFakeTimers();
-    try {
-      const onTimeout = vi.fn();
-      const promise = resolvePermissionWithTimeout(() => new Promise(() => {}), 1000, onTimeout);
-      await vi.advanceTimersByTimeAsync(1000);
-      await expect(promise).resolves.toEqual({ outcome: { outcome: "cancelled" } });
-      expect(onTimeout).toHaveBeenCalledOnce();
-    } finally {
-      vi.useRealTimers();
-    }
+    const onTimeout = vi.fn();
+    await expect(resolvePermissionWithTimeout(() => new Promise(() => {}), 50, onTimeout)).resolves.toEqual({
+      outcome: { outcome: "cancelled" },
+    });
+    expect(onTimeout).toHaveBeenCalledOnce();
   });
 
   it("returns the resolver result when it settles before the timeout", async () => {

apps/daemon/test/daemonSessionRoutes.test.ts

@@ -887,6 +887,7 @@ describe("daemon ACP session routes", () => {
 
     vi.spyOn(provider as any, "getRuntime").mockResolvedValue(runtime);
     vi.spyOn(provider as any, "cancelGeneration").mockResolvedValue(undefined);
+    vi.spyOn(provider as any, "interruptActiveTurn").mockResolvedValue(undefined);
     vi.spyOn(provider as any, "sendMessage").mockResolvedValue({ requestId: null, messageId: null });
 
     await expect(provider.setAcpSessionConfigOption("session-1", "__acp_legacy_model__", "model-b")).resolves.toEqual({
@@ -905,7 +906,7 @@ describe("daemon ACP session routes", () => {
     });
 
     await expect(provider.steerActiveTurn("session-1", "steer this")).resolves.toBeUndefined();
-    expect(provider.cancelGeneration).toHaveBeenCalledWith("session-1");
+    expect(provider.interruptActiveTurn).toHaveBeenCalledWith("session-1");
     expect(provider.sendMessage).toHaveBeenCalledWith("session-1", "steer this");
     expect(runtime.processManager.updateBoundProcessConfigState).toHaveBeenCalledWith("session-1", {
       source: "legacy",

apps/desktop/src/main/routes/settings/settingsAdapter.ts

@@ -30,6 +30,7 @@ export const readSettingsSnapshot = (configPresenter: IConfigPresenter): Setting
   traceDebugEnabled: configPresenter.getSetting<boolean>("traceDebugEnabled") ?? false,
   copyWithCotEnabled: configPresenter.getCopyWithCotEnabled(),
   loggingEnabled: configPresenter.getLoggingEnabled(),
+  showContinueIndicator: configPresenter.getSetting<boolean>("showContinueIndicator") ?? false,
 });
 
 export const pickSettingsSnapshot = (
@@ -93,6 +94,9 @@ export const applySettingChange = (configPresenter: IConfigPresenter, change: Se
     case "loggingEnabled":
       configPresenter.setLoggingEnabled(change.value);
       return;
+    case "showContinueIndicator":
+      configPresenter.setSetting("showContinueIndicator", change.value);
+      return;
   }
 };