From 261959104a4339e355bc414481b7c7a34c3214b1 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Mon, 6 Apr 2026 19:00:47 +0200
Subject: [PATCH 01/61] fix(backend/copilot): skip AI blocks without model
 property in fix_ai_model_parameter

Some AI-category blocks do not expose a "model" input property in their
inputSchema. The fixer was injecting a default model value into these blocks,
which is incorrect. Now checks for the presence of "model" in inputSchema
properties before attempting to set or validate the model field.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/tools/agent_generator/fixer.py    | 10 +++++---
 .../tools/agent_generator/fixer_test.py       | 23 +++++++++++++++++++
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer.py b/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer.py
index 50d0e1925af8..adebd89bf17b 100644
--- a/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer.py
+++ b/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer.py
@@ -890,6 +890,12 @@ def fix_ai_model_parameter(
             )
 
             if is_ai_block:
+                # Skip AI blocks that don't expose a "model" input property
+                # (some AI-category blocks have no model selector at all).
+                input_properties = block.get("inputSchema", {}).get("properties", {})
+                if "model" not in input_properties:
+                    continue
+
                 node_id = node.get("id")
                 input_default = node.get("input_default", {})
                 current_model = input_default.get("model")
@@ -898,9 +904,7 @@ def fix_ai_model_parameter(
                 # Blocks with a block-specific enum on the model field (e.g.
                 # PerplexityBlock) use their own enum values; others use the
                 # generic set.
-                model_schema = (
-                    block.get("inputSchema", {}).get("properties", {}).get("model", {})
-                )
+                model_schema = input_properties.get("model", {})
                 block_model_enum = model_schema.get("enum")
 
                 if block_model_enum:
diff --git a/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer_test.py b/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer_test.py
index 07d71a941cd7..2319ad676044 100644
--- a/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/agent_generator/fixer_test.py
@@ -580,6 +580,29 @@ def test_block_specific_enum_missing_model_gets_block_default(self):
 
         assert result["nodes"][0]["input_default"]["model"] == "perplexity/sonar"
 
+    def test_ai_block_without_model_property_is_skipped(self):
+        """AI-category blocks that have no 'model' input property should not
+        have a model injected — they simply don't expose a model selector."""
+        fixer = AgentFixer()
+        block_id = generate_uuid()
+        node = _make_node(node_id="n1", block_id=block_id, input_default={})
+        agent = _make_agent(nodes=[node])
+
+        blocks = [
+            {
+                "id": block_id,
+                "name": "SomeAIBlock",
+                "categories": [{"category": "AI"}],
+                "inputSchema": {
+                    "properties": {"prompt": {"type": "string"}},
+                },
+            }
+        ]
+
+        result = fixer.fix_ai_model_parameter(agent, blocks)
+
+        assert "model" not in result["nodes"][0]["input_default"]
+
 
 class TestFixAgentExecutorBlocks:
     """Tests for fix_agent_executor_blocks."""

From 5bb919e7b5b609940ec73dbdfb57f2b917ce7cda Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 8 Apr 2026 14:33:49 +0200
Subject: [PATCH 02/61] feat(copilot): add task decomposition for agent
 building

Add a decompose_goal tool that breaks user goals into sub-instructions
before building. Users see a plan checklist and can approve or modify
before the agent is created, improving transparency and control.

- Backend: DecomposeGoalTool, TaskDecompositionResponse model, system prompt update
- Frontend: DecomposeGoal component with StepItem checklist, approve/modify buttons

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../backend/backend/copilot/prompting.py      |  11 ++
 .../backend/backend/copilot/tools/__init__.py |   2 +
 .../backend/copilot/tools/decompose_goal.py   | 130 +++++++++++++++
 .../backend/backend/copilot/tools/models.py   |  35 ++++
 .../components/MessagePartRenderer.tsx        |   3 +
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 124 ++++++++++++++
 .../DecomposeGoal/components/StepItem.tsx     |  39 +++++
 .../copilot/tools/DecomposeGoal/helpers.tsx   | 152 ++++++++++++++++++
 8 files changed, 496 insertions(+)
 create mode 100644 autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
 create mode 100644 autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
 create mode 100644 autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx
 create mode 100644 autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx

diff --git a/autogpt_platform/backend/backend/copilot/prompting.py b/autogpt_platform/backend/backend/copilot/prompting.py
index dd630a2e9b06..3fdba6fc338e 100644
--- a/autogpt_platform/backend/backend/copilot/prompting.py
+++ b/autogpt_platform/backend/backend/copilot/prompting.py
@@ -127,6 +127,17 @@
   non-overlapping scope to avoid redundant searches.
 
 
+### Agent Building Workflow — ALWAYS follow this
+When the user asks to create an agent, ALWAYS follow this workflow:
+1. Analyze the goal and break it into logical sub-instructions.
+2. Call `decompose_goal` with the steps (each step = one logical task like
+   "add input block", "add AI summarizer", "wire blocks together").
+3. Wait for user approval before proceeding.
+4. After approval, call `create_agent` with the full agent JSON.
+
+For simple goals (1-2 blocks), keep the decomposition brief (2-3 steps).
+For complex goals, decompose into 4-8 steps max.
+
 ### Tool Discovery Priority
 
 When the user asks to interact with a service or API, follow this order:
diff --git a/autogpt_platform/backend/backend/copilot/tools/__init__.py b/autogpt_platform/backend/backend/copilot/tools/__init__.py
index 6d1a054c32f9..a15624776f1a 100644
--- a/autogpt_platform/backend/backend/copilot/tools/__init__.py
+++ b/autogpt_platform/backend/backend/copilot/tools/__init__.py
@@ -17,6 +17,7 @@
 from .continue_run_block import ContinueRunBlockTool
 from .create_agent import CreateAgentTool
 from .customize_agent import CustomizeAgentTool
+from .decompose_goal import DecomposeGoalTool
 from .edit_agent import EditAgentTool
 from .feature_requests import CreateFeatureRequestTool, SearchFeatureRequestsTool
 from .find_agent import FindAgentTool
@@ -59,6 +60,7 @@
     "ask_question": AskQuestionTool(),
     "create_agent": CreateAgentTool(),
     "customize_agent": CustomizeAgentTool(),
+    "decompose_goal": DecomposeGoalTool(),
     "edit_agent": EditAgentTool(),
     "find_agent": FindAgentTool(),
     "find_block": FindBlockTool(),
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
new file mode 100644
index 000000000000..598b0c597b3e
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -0,0 +1,130 @@
+"""DecomposeGoalTool - Breaks agent-building goals into sub-instructions."""
+
+import logging
+from typing import Any
+
+from backend.copilot.model import ChatSession
+
+from .base import BaseTool
+from .models import (
+    DecompositionStepModel,
+    ErrorResponse,
+    TaskDecompositionResponse,
+    ToolResponseBase,
+)
+
+logger = logging.getLogger(__name__)
+
+MAX_STEPS = 10
+
+
+class DecomposeGoalTool(BaseTool):
+    """Tool for decomposing an agent goal into sub-instructions."""
+
+    @property
+    def name(self) -> str:
+        return "decompose_goal"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Break down an agent-building goal into logical sub-instructions. "
+            "Each step maps to one task (e.g. add a block, wire connections, "
+            "configure settings). ALWAYS call this before create_agent to show "
+            "the user your plan and get approval."
+        )
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "goal": {
+                    "type": "string",
+                    "description": "The user's agent-building goal.",
+                },
+                "steps": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "description": {
+                                "type": "string",
+                                "description": "Human-readable step description.",
+                            },
+                            "action": {
+                                "type": "string",
+                                "description": (
+                                    "Action type: 'add_block', 'connect_blocks', "
+                                    "'configure', 'add_input', 'add_output'."
+                                ),
+                            },
+                            "block_name": {
+                                "type": "string",
+                                "description": "Block name if adding a block.",
+                            },
+                        },
+                        "required": ["description", "action"],
+                    },
+                    "description": "List of sub-instructions for the plan.",
+                },
+                "require_approval": {
+                    "type": "boolean",
+                    "description": "Whether to ask user for approval (default: true).",
+                    "default": True,
+                },
+            },
+            "required": ["goal", "steps"],
+        }
+
+    async def _execute(
+        self,
+        user_id: str | None,
+        session: ChatSession,
+        goal: str | None = None,
+        steps: list[dict[str, Any]] | None = None,
+        require_approval: bool = True,
+        **kwargs,
+    ) -> ToolResponseBase:
+        session_id = session.session_id if session else None
+
+        if not goal:
+            return ErrorResponse(
+                message="Please provide a goal to decompose.",
+                error="missing_goal",
+                session_id=session_id,
+            )
+
+        if not steps:
+            return ErrorResponse(
+                message="Please provide at least one step in the plan.",
+                error="missing_steps",
+                session_id=session_id,
+            )
+
+        if len(steps) > MAX_STEPS:
+            return ErrorResponse(
+                message=f"Too many steps ({len(steps)}). Keep the plan to {MAX_STEPS} steps max.",
+                error="too_many_steps",
+                session_id=session_id,
+            )
+
+        decomposition_steps = [
+            DecompositionStepModel(
+                step_id=f"step_{i + 1}",
+                description=step.get("description", ""),
+                action=step.get("action", "add_block"),
+                block_name=step.get("block_name"),
+                status="pending",
+            )
+            for i, step in enumerate(steps)
+        ]
+
+        return TaskDecompositionResponse(
+            message=f"Here's the plan to build your agent ({len(decomposition_steps)} steps):",
+            goal=goal,
+            steps=decomposition_steps,
+            step_count=len(decomposition_steps),
+            requires_approval=require_approval,
+            session_id=session_id,
+        )
diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.py
index a0d1ad13ef05..6c65764469c2 100644
--- a/autogpt_platform/backend/backend/copilot/tools/models.py
+++ b/autogpt_platform/backend/backend/copilot/tools/models.py
@@ -36,6 +36,9 @@ class ResponseType(str, Enum):
     AGENT_BUILDER_VALIDATION_RESULT = "agent_builder_validation_result"
     AGENT_BUILDER_FIX_RESULT = "agent_builder_fix_result"
 
+    # Task decomposition (goal → sub-instructions)
+    TASK_DECOMPOSITION = "task_decomposition"
+
     # Block
     BLOCK_LIST = "block_list"
     BLOCK_DETAILS = "block_details"
@@ -688,3 +691,35 @@ class AgentsMovedToFolderResponse(ToolResponseBase):
     agent_names: list[str] = []
     folder_id: str | None = None
     count: int = 0
+
+
+# Task decomposition models
+
+
+class DecompositionStepModel(BaseModel):
+    """A single step in a decomposed agent-building plan."""
+
+    step_id: str = Field(description="Unique step identifier, e.g. 'step_1'")
+    description: str = Field(description="Human-readable step description")
+    action: str = Field(
+        description="Action type: 'add_block', 'connect_blocks', 'configure', etc."
+    )
+    block_name: str | None = Field(
+        default=None, description="Block being added, if applicable"
+    )
+    status: str = Field(
+        default="pending",
+        description="Step status: pending, in_progress, completed, failed",
+    )
+
+
+class TaskDecompositionResponse(ToolResponseBase):
+    """Response for decompose_goal tool — shows the plan to the user."""
+
+    type: ResponseType = ResponseType.TASK_DECOMPOSITION
+    goal: str = Field(description="The original user goal")
+    steps: list[DecompositionStepModel]
+    step_count: int
+    requires_approval: bool = True
+
+
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
index 5d129a0a7885..0668ea1e24d1 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
@@ -5,6 +5,7 @@ import { ToolUIPart, UIDataTypes, UIMessage, UITools } from "ai";
 import { AskQuestionTool } from "../../../tools/AskQuestion/AskQuestion";
 import { ConnectIntegrationTool } from "../../../tools/ConnectIntegrationTool/ConnectIntegrationTool";
 import { CreateAgentTool } from "../../../tools/CreateAgent/CreateAgent";
+import { DecomposeGoalTool } from "../../../tools/DecomposeGoal/DecomposeGoal";
 import { EditAgentTool } from "../../../tools/EditAgent/EditAgent";
 import {
   CreateFeatureRequestTool,
@@ -144,6 +145,8 @@ export function MessagePartRenderer({
     case "tool-run_agent":
     case "tool-schedule_agent":
       return <RunAgentTool key={key} part={part as ToolUIPart} />;
+    case "tool-decompose_goal":
+      return <DecomposeGoalTool key={key} part={part as ToolUIPart} />;
     case "tool-create_agent":
       return <CreateAgentTool key={key} part={part as ToolUIPart} />;
     case "tool-edit_agent":
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
new file mode 100644
index 000000000000..18abeb9fbab0
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -0,0 +1,124 @@
+"use client";
+
+import { Button } from "@/components/atoms/Button/Button";
+import { CheckIcon, PencilSimpleIcon } from "@phosphor-icons/react";
+import type { ToolUIPart } from "ai";
+import { useCopilotChatActions } from "../../components/CopilotChatActionsProvider/useCopilotChatActions";
+import { MorphingTextAnimation } from "../../components/MorphingTextAnimation/MorphingTextAnimation";
+import {
+  ContentGrid,
+  ContentHint,
+  ContentMessage,
+} from "../../components/ToolAccordion/AccordionContent";
+import { ToolAccordion } from "../../components/ToolAccordion/ToolAccordion";
+import { ToolErrorCard } from "../../components/ToolErrorCard/ToolErrorCard";
+import { StepItem } from "./components/StepItem";
+import {
+  AccordionIcon,
+  getAnimationText,
+  getDecomposeGoalOutput,
+  isDecompositionOutput,
+  isErrorOutput,
+  ToolIcon,
+} from "./helpers";
+
+interface Props {
+  part: ToolUIPart;
+}
+
+export function DecomposeGoalTool({ part }: Props) {
+  const text = getAnimationText(part);
+  const { onSend } = useCopilotChatActions();
+
+  const isStreaming =
+    part.state === "input-streaming" || part.state === "input-available";
+
+  const output = getDecomposeGoalOutput(part);
+
+  const isError =
+    part.state === "output-error" || (!!output && isErrorOutput(output));
+
+  const isOperating = !output;
+
+  function handleApprove() {
+    onSend("Approved. Please build the agent.");
+  }
+
+  function handleModify() {
+    onSend("I'd like to modify the plan. Here are my changes: ");
+  }
+
+  return (
+    <div className="py-2">
+      {isOperating && (
+        <div className="flex items-center gap-2 text-sm text-muted-foreground">
+          <ToolIcon isStreaming={isStreaming} isError={isError} />
+          <MorphingTextAnimation
+            text={text}
+            className={isError ? "text-red-500" : undefined}
+          />
+        </div>
+      )}
+
+      {isError && output && isErrorOutput(output) && (
+        <ToolErrorCard
+          message={output.message ?? ""}
+          fallbackMessage="Failed to analyze the goal. Please try again."
+          actions={[
+            {
+              label: "Try again",
+              onClick: () => onSend("Please try decomposing the goal again."),
+            },
+          ]}
+        />
+      )}
+
+      {output && isDecompositionOutput(output) && (
+        <ToolAccordion
+          icon={<AccordionIcon />}
+          title={`Build Plan — ${output.step_count} steps`}
+          description={output.goal}
+          defaultExpanded
+        >
+          <ContentGrid>
+            <ContentMessage>{output.message}</ContentMessage>
+
+            <div className="space-y-0.5 rounded-lg border border-slate-200 bg-white p-3">
+              {output.steps.map((step, i) => (
+                <StepItem
+                  key={step.step_id}
+                  index={i}
+                  description={step.description}
+                  action={step.action}
+                  blockName={step.block_name}
+                  status={step.status}
+                />
+              ))}
+            </div>
+
+            {output.requires_approval && (
+              <div className="flex items-center gap-2 pt-1">
+                <Button variant="primary" onClick={handleApprove}>
+                  <span className="inline-flex items-center gap-1.5">
+                    <CheckIcon size={14} weight="bold" />
+                    Approve
+                  </span>
+                </Button>
+                <Button variant="ghost" onClick={handleModify}>
+                  <span className="inline-flex items-center gap-1.5">
+                    <PencilSimpleIcon size={14} weight="bold" />
+                    Modify
+                  </span>
+                </Button>
+              </div>
+            )}
+
+            <ContentHint>
+              Review the plan above and approve to start building.
+            </ContentHint>
+          </ContentGrid>
+        </ToolAccordion>
+      )}
+    </div>
+  );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx
new file mode 100644
index 000000000000..ac1305e70674
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx
@@ -0,0 +1,39 @@
+"use client";
+
+import { Text } from "@/components/atoms/Text/Text";
+import { CubeIcon } from "@phosphor-icons/react";
+import { StepStatusIcon } from "../helpers";
+
+interface Props {
+  index: number;
+  description: string;
+  action: string;
+  blockName?: string | null;
+  status: string;
+}
+
+export function StepItem({ index, description, blockName, status }: Props) {
+  return (
+    <div className="flex items-start gap-3 py-1.5">
+      <div className="mt-0.5 flex shrink-0 items-center">
+        <StepStatusIcon status={status} />
+      </div>
+      <div className="min-w-0 flex-1">
+        <Text variant="body-medium" className="text-sm text-zinc-800">
+          {index + 1}. {description}
+        </Text>
+        {blockName && (
+          <div className="mt-0.5 flex items-center gap-1">
+            <CubeIcon size={12} className="text-neutral-400" />
+            <Text
+              variant="small"
+              className="font-mono text-xs text-neutral-500"
+            >
+              {blockName}
+            </Text>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
new file mode 100644
index 000000000000..ac1111d1e6b4
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -0,0 +1,152 @@
+"use client";
+
+import {
+  CheckCircleIcon,
+  CircleDashedIcon,
+  ListChecksIcon,
+  SpinnerGapIcon,
+  WarningDiamondIcon,
+  XCircleIcon,
+} from "@phosphor-icons/react";
+import type { ToolUIPart } from "ai";
+import { ScaleLoader } from "../../components/ScaleLoader/ScaleLoader";
+
+interface DecompositionStep {
+  step_id: string;
+  description: string;
+  action: string;
+  block_name?: string | null;
+  status: string;
+}
+
+export interface TaskDecompositionOutput {
+  type: string;
+  message: string;
+  goal: string;
+  steps: DecompositionStep[];
+  step_count: number;
+  requires_approval: boolean;
+}
+
+export interface DecomposeErrorOutput {
+  type: string;
+  error?: string;
+  message?: string;
+}
+
+export type DecomposeGoalOutput =
+  | TaskDecompositionOutput
+  | DecomposeErrorOutput;
+
+function parseOutput(output: unknown): DecomposeGoalOutput | null {
+  if (!output) return null;
+  if (typeof output === "string") {
+    const trimmed = output.trim();
+    if (!trimmed) return null;
+    try {
+      return parseOutput(JSON.parse(trimmed) as unknown);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof output === "object") {
+    if ("steps" in output && "goal" in output) {
+      return output as TaskDecompositionOutput;
+    }
+    if ("error" in output) {
+      return output as DecomposeErrorOutput;
+    }
+  }
+  return null;
+}
+
+export function getDecomposeGoalOutput(
+  part: unknown,
+): DecomposeGoalOutput | null {
+  if (!part || typeof part !== "object") return null;
+  return parseOutput((part as { output?: unknown }).output);
+}
+
+export function isDecompositionOutput(
+  output: DecomposeGoalOutput,
+): output is TaskDecompositionOutput {
+  return "steps" in output && "goal" in output;
+}
+
+export function isErrorOutput(
+  output: DecomposeGoalOutput,
+): output is DecomposeErrorOutput {
+  return "error" in output;
+}
+
+export function getAnimationText(part: {
+  state: ToolUIPart["state"];
+  output?: unknown;
+}): string {
+  switch (part.state) {
+    case "input-streaming":
+    case "input-available":
+      return "Analyzing your goal...";
+    case "output-available": {
+      const output = parseOutput(part.output);
+      if (output && isDecompositionOutput(output))
+        return `Plan ready (${output.step_count} steps)`;
+      return "Analyzing your goal...";
+    }
+    case "output-error":
+      return "Error analyzing goal";
+    default:
+      return "Analyzing your goal...";
+  }
+}
+
+export function ToolIcon({
+  isStreaming,
+  isError,
+}: {
+  isStreaming?: boolean;
+  isError?: boolean;
+}) {
+  if (isError) {
+    return (
+      <WarningDiamondIcon size={14} weight="regular" className="text-red-500" />
+    );
+  }
+  if (isStreaming) {
+    return <ScaleLoader size={14} />;
+  }
+  return (
+    <ListChecksIcon size={14} weight="regular" className="text-neutral-400" />
+  );
+}
+
+export function AccordionIcon() {
+  return <ListChecksIcon size={32} weight="light" />;
+}
+
+export function StepStatusIcon({ status }: { status: string }) {
+  switch (status) {
+    case "completed":
+      return (
+        <CheckCircleIcon size={18} weight="fill" className="text-emerald-500" />
+      );
+    case "in_progress":
+      return (
+        <SpinnerGapIcon
+          size={18}
+          weight="bold"
+          className="animate-spin text-blue-500"
+        />
+      );
+    case "failed":
+      return <XCircleIcon size={18} weight="fill" className="text-red-500" />;
+    default:
+      return (
+        <CircleDashedIcon
+          size={18}
+          weight="regular"
+          className="text-neutral-400"
+        />
+      );
+  }
+}

From f330699a89c9dc12a4fe25f8156326e6caccea34 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 8 Apr 2026 23:36:17 +0200
Subject: [PATCH 03/61] =?UTF-8?q?fix(copilot):=20improve=20decompose=5Fgoa?=
 =?UTF-8?q?l=20UX=20=E2=80=94=20pin=20box=20post-stream,=20suppress=20comp?=
 =?UTF-8?q?anion=20text?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Move decomposition prompt from prompting.py to agent_generation_guide.md as a required pre-build gate
- Add tool-decompose_goal to CUSTOM_TOOL_TYPES so it renders individually (not collapsed)
- Add task_decomposition to INTERACTIVE_RESPONSE_TYPES so the box is pinned to response after streaming
- Filter out text parts (table) from response when decompose_goal is pinned
- Hide decompose_goal during streaming so the box only appears once all reasoning is complete and Approve is immediately actionable

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/backend/copilot/prompting.py            | 11 -----------
 .../backend/copilot/sdk/agent_generation_guide.md   | 13 +++++++++++++
 .../ChatMessagesContainer/ChatMessagesContainer.tsx |  7 ++++++-
 .../components/ChatMessagesContainer/helpers.ts     | 11 ++++++++++-
 4 files changed, 29 insertions(+), 13 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/prompting.py b/autogpt_platform/backend/backend/copilot/prompting.py
index 3fdba6fc338e..dd630a2e9b06 100644
--- a/autogpt_platform/backend/backend/copilot/prompting.py
+++ b/autogpt_platform/backend/backend/copilot/prompting.py
@@ -127,17 +127,6 @@
   non-overlapping scope to avoid redundant searches.
 
 
-### Agent Building Workflow — ALWAYS follow this
-When the user asks to create an agent, ALWAYS follow this workflow:
-1. Analyze the goal and break it into logical sub-instructions.
-2. Call `decompose_goal` with the steps (each step = one logical task like
-   "add input block", "add AI summarizer", "wire blocks together").
-3. Wait for user approval before proceeding.
-4. After approval, call `create_agent` with the full agent JSON.
-
-For simple goals (1-2 blocks), keep the decomposition brief (2-3 steps).
-For complex goals, decompose into 4-8 steps max.
-
 ### Tool Discovery Priority
 
 When the user asks to interact with a service or API, follow this order:
diff --git a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
index 28b6f1c7dc4d..00750e3b1f7b 100644
--- a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
+++ b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
@@ -26,6 +26,19 @@ Steps:
 **Skip this** when the goal already specifies all dimensions (e.g.
 "scrape prices from Amazon and email me daily").
 
+### Before Building: Goal Decomposition (REQUIRED)
+
+Before running the workflow below, ALWAYS decompose the goal first:
+
+1. Analyze the user's request and break it into logical build steps (e.g.
+   "add input block", "add AI summarizer", "wire blocks together").
+2. Call `decompose_goal` with those steps.
+3. **STOP — do not proceed until the user approves the plan.**
+4. Only after approval, continue with "Workflow for Creating/Editing Agents".
+
+For simple goals (1-2 blocks), keep steps brief (2-3 steps).
+For complex goals, decompose into 4-8 steps max.
+
 ### Workflow for Creating/Editing Agents
 
 1. **If editing**: First narrow to the specific agent by UUID, then fetch its
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
index 205fa74bd0ce..89cad821ed06 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
@@ -214,7 +214,12 @@ export function ChatMessagesContainer({
             message.role === "assistant" && !isCurrentlyStreaming;
           const { reasoning, response } = isFinalized
             ? splitReasoningAndResponse(message.parts)
-            : { reasoning: [] as MessagePart[], response: message.parts };
+            : {
+                reasoning: [] as MessagePart[],
+                response: message.parts.filter(
+                  (p) => p.type !== "tool-decompose_goal",
+                ),
+              };
           const hasReasoning = reasoning.length > 0;
 
           // Note: when interactive tools are pinned from reasoning into response,
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
index c859ba791fe8..64425dd1622e 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
@@ -29,6 +29,7 @@ const CUSTOM_TOOL_TYPES = new Set([
   "tool-view_agent_output",
   "tool-search_feature_requests",
   "tool-create_feature_request",
+  "tool-decompose_goal",
 ]);
 
 const INTERACTIVE_RESPONSE_TYPES: ReadonlySet<string> = new Set([
@@ -42,6 +43,7 @@ const INTERACTIVE_RESPONSE_TYPES: ReadonlySet<string> = new Set([
   ResponseType.suggested_goal,
   ResponseType.agent_builder_preview,
   ResponseType.agent_builder_saved,
+  ResponseType.task_decomposition,
 ]);
 
 export function isCompletedToolPart(part: MessagePart): part is ToolUIPart {
@@ -148,9 +150,16 @@ export function splitReasoningAndResponse(parts: MessagePart[]): {
     }
   }
 
+  const hasDecomposeGoal = pinnedParts.some(
+    (p) => p.type === "tool-decompose_goal",
+  );
+  const filteredResponse = hasDecomposeGoal
+    ? rawResponse.filter((p) => p.type !== "text")
+    : rawResponse;
+
   return {
     reasoning,
-    response: [...pinnedParts, ...rawResponse],
+    response: [...pinnedParts, ...filteredResponse],
   };
 }
 

From 703d34364d30313759ecad38f63409df8368c764 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 8 Apr 2026 23:37:25 +0200
Subject: [PATCH 04/61] chore(frontend): update openapi.json snapshot

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 autogpt_platform/frontend/src/app/api/openapi.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 3ca7e5707bc5..e183ee59487e 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -12100,6 +12100,7 @@
           "agent_builder_clarification_needed",
           "agent_builder_validation_result",
           "agent_builder_fix_result",
+          "task_decomposition",
           "block_list",
           "block_details",
           "block_output",

From 629fb4d3bb2732f5947ab545ad9eb06deade3a62 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 12:27:05 +0200
Subject: [PATCH 05/61] fix(copilot): allow sub-instructions companion text and
 restore streaming render
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Revert ChatMessagesContainer streaming filter — decompose_goal now visible during stream
- Remove text suppression in splitReasoningAndResponse — table message is allowed alongside sub-instructions box

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../ChatMessagesContainer/ChatMessagesContainer.tsx      | 7 +------
 .../copilot/components/ChatMessagesContainer/helpers.ts  | 9 +--------
 2 files changed, 2 insertions(+), 14 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
index 89cad821ed06..205fa74bd0ce 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
@@ -214,12 +214,7 @@ export function ChatMessagesContainer({
             message.role === "assistant" && !isCurrentlyStreaming;
           const { reasoning, response } = isFinalized
             ? splitReasoningAndResponse(message.parts)
-            : {
-                reasoning: [] as MessagePart[],
-                response: message.parts.filter(
-                  (p) => p.type !== "tool-decompose_goal",
-                ),
-              };
+            : { reasoning: [] as MessagePart[], response: message.parts };
           const hasReasoning = reasoning.length > 0;
 
           // Note: when interactive tools are pinned from reasoning into response,
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
index 64425dd1622e..94113b06860d 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
@@ -150,16 +150,9 @@ export function splitReasoningAndResponse(parts: MessagePart[]): {
     }
   }
 
-  const hasDecomposeGoal = pinnedParts.some(
-    (p) => p.type === "tool-decompose_goal",
-  );
-  const filteredResponse = hasDecomposeGoal
-    ? rawResponse.filter((p) => p.type !== "text")
-    : rawResponse;
-
   return {
     reasoning,
-    response: [...pinnedParts, ...filteredResponse],
+    response: [...pinnedParts, ...rawResponse],
   };
 }
 

From 5fa33111de452912ff22bbf6ad000ec4e0666ff2 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 21:50:43 +0200
Subject: [PATCH 06/61] feat(copilot): add auto-approve timer with editable
 steps to decompose_goal UI
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Replace static Approve/Modify buttons with a 99s countdown timer that
  auto-approves when it expires
- Timer ring animates inline within "Starting in [N]s" text using SVG
  strokeDasharray; hover on the text swaps it to "Start now" via Tailwind
  named groups (group/label)
- Clicking Modify stops the timer, enters editable mode where steps can be
  renamed, deleted, or inserted between existing steps
- In edit mode only Approve is shown; timer and Modify are hidden
- showActions gated on isLastMessage (server-derived) so the timer never
  re-appears when returning to a session with prior messages
- Forward isLastMessage through ChatMessagesContainer → MessagePartRenderer

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../ChatMessagesContainer.tsx                 |   4 +
 .../components/MessagePartRenderer.tsx        |  10 +-
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 274 +++++++++++++++---
 3 files changed, 250 insertions(+), 38 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
index 5161103f4b4a..620c108388aa 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
@@ -50,6 +50,7 @@ function renderSegments(
   segments: RenderSegment[],
   messageID: string,
   onRetry?: () => void,
+  isLastMessage?: boolean,
 ): React.ReactNode[] {
   return segments.map((seg, segIdx) => {
     if (seg.kind === "collapsed-group") {
@@ -62,6 +63,7 @@ function renderSegments(
         messageID={messageID}
         partIndex={seg.index}
         onRetry={onRetry}
+        isLastMessage={isLastMessage}
       />
     );
   });
@@ -372,6 +374,7 @@ export function ChatMessagesContainer({
                       responseSegments,
                       message.id,
                       isLastAssistant ? onRetry : undefined,
+                      isLastAssistant,
                     )
                   : message.parts.map((part, i) => (
                       <MessagePartRenderer
@@ -380,6 +383,7 @@ export function ChatMessagesContainer({
                         messageID={message.id}
                         partIndex={i}
                         onRetry={isLastAssistant ? onRetry : undefined}
+                        isLastMessage={isLastAssistant}
                       />
                     ))}
                 {isLastInTurn && !isCurrentlyStreaming && (
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
index 136192a7d313..b86f73d86bc7 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
@@ -94,6 +94,7 @@ interface Props {
   messageID: string;
   partIndex: number;
   onRetry?: () => void;
+  isLastMessage?: boolean;
 }
 
 export function MessagePartRenderer({
@@ -101,6 +102,7 @@ export function MessagePartRenderer({
   messageID,
   partIndex,
   onRetry,
+  isLastMessage,
 }: Props) {
   const key = `${messageID}-${partIndex}`;
 
@@ -169,7 +171,13 @@ export function MessagePartRenderer({
     case "tool-schedule_agent":
       return <RunAgentTool key={key} part={part as ToolUIPart} />;
     case "tool-decompose_goal":
-      return <DecomposeGoalTool key={key} part={part as ToolUIPart} />;
+      return (
+        <DecomposeGoalTool
+          key={key}
+          part={part as ToolUIPart}
+          isLastMessage={isLastMessage}
+        />
+      );
     case "tool-create_agent":
       return <CreateAgentTool key={key} part={part as ToolUIPart} />;
     case "tool-edit_agent":
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 18abeb9fbab0..fde9c67dc46d 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -1,13 +1,18 @@
 "use client";
 
 import { Button } from "@/components/atoms/Button/Button";
-import { CheckIcon, PencilSimpleIcon } from "@phosphor-icons/react";
+import {
+  CheckIcon,
+  PencilSimpleIcon,
+  PlusIcon,
+  TrashIcon,
+} from "@phosphor-icons/react";
 import type { ToolUIPart } from "ai";
+import { useEffect, useRef, useState } from "react";
 import { useCopilotChatActions } from "../../components/CopilotChatActionsProvider/useCopilotChatActions";
 import { MorphingTextAnimation } from "../../components/MorphingTextAnimation/MorphingTextAnimation";
 import {
   ContentGrid,
-  ContentHint,
   ContentMessage,
 } from "../../components/ToolAccordion/AccordionContent";
 import { ToolAccordion } from "../../components/ToolAccordion/ToolAccordion";
@@ -22,11 +27,24 @@ import {
   ToolIcon,
 } from "./helpers";
 
+const COUNTDOWN_SECONDS = 99;
+const RADIUS = 15;
+const CIRCUMFERENCE = 2 * Math.PI * RADIUS;
+
+interface EditableStep {
+  step_id: string;
+  description: string;
+  action: string;
+  block_name?: string | null;
+  status: string;
+}
+
 interface Props {
   part: ToolUIPart;
+  isLastMessage?: boolean;
 }
 
-export function DecomposeGoalTool({ part }: Props) {
+export function DecomposeGoalTool({ part, isLastMessage }: Props) {
   const text = getAnimationText(part);
   const { onSend } = useCopilotChatActions();
 
@@ -34,20 +52,102 @@ export function DecomposeGoalTool({ part }: Props) {
     part.state === "input-streaming" || part.state === "input-available";
 
   const output = getDecomposeGoalOutput(part);
-
   const isError =
     part.state === "output-error" || (!!output && isErrorOutput(output));
-
   const isOperating = !output;
 
-  function handleApprove() {
-    onSend("Approved. Please build the agent.");
+  const showActions =
+    !!isLastMessage &&
+    !!output &&
+    isDecompositionOutput(output) &&
+    output.requires_approval;
+
+  const [secondsLeft, setSecondsLeft] = useState(COUNTDOWN_SECONDS);
+  // timerActive becomes false when the user clicks Modify — stops countdown and auto-approve.
+  const [timerActive, setTimerActive] = useState(true);
+  const [isEditing, setIsEditing] = useState(false);
+  const [editableSteps, setEditableSteps] = useState<EditableStep[]>([]);
+
+  const approvedRef = useRef(false);
+  const onSendRef = useRef(onSend);
+  const isEditingRef = useRef(isEditing);
+  const editableStepsRef = useRef(editableSteps);
+  onSendRef.current = onSend;
+  isEditingRef.current = isEditing;
+  editableStepsRef.current = editableSteps;
+
+  function buildMessage() {
+    if (isEditingRef.current && editableStepsRef.current.length > 0) {
+      const list = editableStepsRef.current
+        .map((s, i) => `${i + 1}. ${s.description}`)
+        .join("; ");
+      return `Approved with modifications. Please build the agent following these steps: ${list}`;
+    }
+    return "Approved. Please build the agent.";
+  }
+
+  function approve() {
+    if (approvedRef.current) return;
+    approvedRef.current = true;
+    setIsEditing(false);
+    onSendRef.current(buildMessage());
   }
 
   function handleModify() {
-    onSend("I'd like to modify the plan. Here are my changes: ");
+    if (!output || !isDecompositionOutput(output)) return;
+    setTimerActive(false);
+    setIsEditing(true);
+    setEditableSteps(output.steps.map((s) => ({ ...s })));
   }
 
+  function handleStepChange(index: number, description: string) {
+    setEditableSteps((prev) =>
+      prev.map((s, i) => (i === index ? { ...s, description } : s)),
+    );
+  }
+
+  function handleStepDelete(index: number) {
+    setEditableSteps((prev) => prev.filter((_, i) => i !== index));
+  }
+
+  // Insert a blank step after the given index (-1 = prepend).
+  function handleStepInsert(afterIndex: number) {
+    setEditableSteps((prev) => {
+      const next = [...prev];
+      next.splice(afterIndex + 1, 0, {
+        step_id: `step_new_${Date.now()}`,
+        description: "",
+        action: "add_block",
+        status: "pending",
+      });
+      return next;
+    });
+  }
+
+  // Tick down only while the timer is active.
+  useEffect(() => {
+    if (!showActions || !timerActive) return;
+    const interval = setInterval(() => {
+      setSecondsLeft((s) => Math.max(0, s - 1));
+    }, 1000);
+    return () => clearInterval(interval);
+  }, [showActions, timerActive, part.toolCallId]);
+
+  // Auto-approve when countdown reaches 0 (only if timer is still active).
+  useEffect(() => {
+    if (secondsLeft === 0 && timerActive) approve();
+    // approve is stable via ref — intentionally omitted
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [secondsLeft, timerActive]);
+
+  const progress = secondsLeft / COUNTDOWN_SECONDS;
+  const dashOffset = CIRCUMFERENCE * (1 - progress);
+  const stepCount = isEditing
+    ? editableSteps.length
+    : output && isDecompositionOutput(output)
+      ? output.step_count
+      : 0;
+
   return (
     <div className="py-2">
       {isOperating && (
@@ -76,49 +176,149 @@ export function DecomposeGoalTool({ part }: Props) {
       {output && isDecompositionOutput(output) && (
         <ToolAccordion
           icon={<AccordionIcon />}
-          title={`Build Plan — ${output.step_count} steps`}
+          title={`Build Plan — ${stepCount} steps`}
           description={output.goal}
           defaultExpanded
         >
           <ContentGrid>
             <ContentMessage>{output.message}</ContentMessage>
 
-            <div className="space-y-0.5 rounded-lg border border-slate-200 bg-white p-3">
-              {output.steps.map((step, i) => (
-                <StepItem
-                  key={step.step_id}
-                  index={i}
-                  description={step.description}
-                  action={step.action}
-                  blockName={step.block_name}
-                  status={step.status}
-                />
-              ))}
+            <div className="rounded-lg border border-slate-200 bg-white p-3">
+              {isEditing ? (
+                <div className="flex flex-col">
+                  {/* Insert before the first step */}
+                  <InsertButton onClick={() => handleStepInsert(-1)} />
+
+                  {editableSteps.map((step, i) => (
+                    <div key={step.step_id} className="flex flex-col">
+                      <div className="flex items-center gap-2 py-1">
+                        <span className="w-5 shrink-0 text-xs text-slate-400">
+                          {i + 1}.
+                        </span>
+                        <input
+                          type="text"
+                          value={step.description}
+                          onChange={(e) => handleStepChange(i, e.target.value)}
+                          className="flex-1 rounded border border-slate-200 px-2 py-1 text-sm focus:border-neutral-400 focus:outline-none"
+                          placeholder="Step description"
+                        />
+                        <button
+                          type="button"
+                          onClick={() => handleStepDelete(i)}
+                          className="text-slate-400 hover:text-red-500"
+                          aria-label="Remove step"
+                        >
+                          <TrashIcon size={14} />
+                        </button>
+                      </div>
+                      {/* Insert after each step */}
+                      <InsertButton onClick={() => handleStepInsert(i)} />
+                    </div>
+                  ))}
+                </div>
+              ) : (
+                <div className="space-y-0.5">
+                  {output.steps.map((step, i) => (
+                    <StepItem
+                      key={step.step_id}
+                      index={i}
+                      description={step.description}
+                      action={step.action}
+                      blockName={step.block_name}
+                      status={step.status}
+                    />
+                  ))}
+                </div>
+              )}
             </div>
 
-            {output.requires_approval && (
+            {showActions && (
               <div className="flex items-center gap-2 pt-1">
-                <Button variant="primary" onClick={handleApprove}>
-                  <span className="inline-flex items-center gap-1.5">
-                    <CheckIcon size={14} weight="bold" />
-                    Approve
-                  </span>
-                </Button>
-                <Button variant="ghost" onClick={handleModify}>
-                  <span className="inline-flex items-center gap-1.5">
-                    <PencilSimpleIcon size={14} weight="bold" />
-                    Modify
-                  </span>
-                </Button>
+                {isEditing ? (
+                  <Button variant="primary" onClick={approve}>
+                    <span className="inline-flex items-center gap-1.5">
+                      <CheckIcon size={14} weight="bold" />
+                      Approve
+                    </span>
+                  </Button>
+                ) : (
+                  <>
+                    {/* Timer button — same ghost style as Modify, ring wraps the number inline */}
+                    <Button variant="ghost" onClick={approve}>
+                      <span className="group/label inline-flex items-center gap-1">
+                        <span className="inline-flex items-center gap-1 group-hover/label:hidden">
+                          Starting in
+                          <span className="relative inline-flex h-5 w-5 items-center justify-center">
+                            <svg
+                              width="20"
+                              height="20"
+                              viewBox="0 0 34 34"
+                              className="absolute -rotate-90"
+                            >
+                              <circle
+                                cx="17"
+                                cy="17"
+                                r={RADIUS}
+                                fill="none"
+                                stroke="currentColor"
+                                strokeWidth="2"
+                                className="text-neutral-300"
+                              />
+                              <circle
+                                cx="17"
+                                cy="17"
+                                r={RADIUS}
+                                fill="none"
+                                stroke="currentColor"
+                                strokeWidth="2"
+                                strokeLinecap="round"
+                                strokeDasharray={CIRCUMFERENCE}
+                                strokeDashoffset={dashOffset}
+                                className="text-neutral-600 transition-[stroke-dashoffset] duration-1000 ease-linear"
+                              />
+                            </svg>
+                            <span className="relative z-10 text-[9px] font-semibold tabular-nums text-neutral-700">
+                              {secondsLeft}
+                            </span>
+                          </span>
+                          s
+                        </span>
+                        <span className="hidden group-hover/label:inline">
+                          Start now
+                        </span>
+                      </span>
+                    </Button>
+                    <span className="text-neutral-300">|</span>
+                    <Button variant="ghost" onClick={handleModify}>
+                      <span className="inline-flex items-center gap-1.5">
+                        <PencilSimpleIcon size={14} weight="bold" />
+                        Modify
+                      </span>
+                    </Button>
+                  </>
+                )}
               </div>
             )}
-
-            <ContentHint>
-              Review the plan above and approve to start building.
-            </ContentHint>
           </ContentGrid>
         </ToolAccordion>
       )}
     </div>
   );
 }
+
+function InsertButton({ onClick }: { onClick: () => void }) {
+  return (
+    <div className="group flex items-center gap-1 py-0.5">
+      <div className="h-px flex-1 bg-slate-100 group-hover:bg-neutral-300" />
+      <button
+        type="button"
+        onClick={onClick}
+        className="flex items-center gap-0.5 rounded px-1 text-xs text-slate-300 hover:text-neutral-700 focus:outline-none"
+        aria-label="Insert step here"
+      >
+        <PlusIcon size={10} weight="bold" />
+      </button>
+      <div className="h-px flex-1 bg-slate-100 group-hover:bg-neutral-300" />
+    </div>
+  );
+}

From b9d47a8cf59df1660bb212ae63f03cb23fa993e9 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 22:10:51 +0200
Subject: [PATCH 07/61] fix(copilot): auto-size editable step textareas on
 initial render and input

- Replace <input type="text"> with <textarea> for step descriptions
- Use ref callback to set height from scrollHeight on every render so
  long descriptions wrap to multiple lines by default without interaction
- Bump countdown ring container from 20px to 24px and text from 9px to
  11px for better legibility

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index fde9c67dc46d..dbab6ddd7ec1 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -27,7 +27,7 @@ import {
   ToolIcon,
 } from "./helpers";
 
-const COUNTDOWN_SECONDS = 99;
+const COUNTDOWN_SECONDS = 60;
 const RADIUS = 15;
 const CIRCUMFERENCE = 2 * Math.PI * RADIUS;
 
@@ -191,21 +191,27 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
 
                   {editableSteps.map((step, i) => (
                     <div key={step.step_id} className="flex flex-col">
-                      <div className="flex items-center gap-2 py-1">
-                        <span className="w-5 shrink-0 text-xs text-slate-400">
+                      <div className="flex items-start gap-2 py-1">
+                        <span className="w-5 shrink-0 pt-1 text-xs text-slate-400">
                           {i + 1}.
                         </span>
-                        <input
-                          type="text"
+                        <textarea
+                          ref={(el) => {
+                            if (el) {
+                              el.style.height = "auto";
+                              el.style.height = `${el.scrollHeight}px`;
+                            }
+                          }}
                           value={step.description}
                           onChange={(e) => handleStepChange(i, e.target.value)}
-                          className="flex-1 rounded border border-slate-200 px-2 py-1 text-sm focus:border-neutral-400 focus:outline-none"
+                          rows={1}
+                          className="flex-1 resize-none overflow-hidden rounded border border-slate-200 px-2 py-1 text-sm focus:border-neutral-400 focus:outline-none"
                           placeholder="Step description"
                         />
                         <button
                           type="button"
                           onClick={() => handleStepDelete(i)}
-                          className="text-slate-400 hover:text-red-500"
+                          className="mt-1 text-slate-400 hover:text-red-500"
                           aria-label="Remove step"
                         >
                           <TrashIcon size={14} />
@@ -248,10 +254,10 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                       <span className="group/label inline-flex items-center gap-1">
                         <span className="inline-flex items-center gap-1 group-hover/label:hidden">
                           Starting in
-                          <span className="relative inline-flex h-5 w-5 items-center justify-center">
+                          <span className="relative inline-flex h-6 w-6 items-center justify-center">
                             <svg
-                              width="20"
-                              height="20"
+                              width="24"
+                              height="24"
                               viewBox="0 0 34 34"
                               className="absolute -rotate-90"
                             >
@@ -277,7 +283,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                                 className="text-neutral-600 transition-[stroke-dashoffset] duration-1000 ease-linear"
                               />
                             </svg>
-                            <span className="relative z-10 text-[9px] font-semibold tabular-nums text-neutral-700">
+                            <span className="relative z-10 text-[11px] font-semibold tabular-nums text-neutral-700">
                               {secondsLeft}
                             </span>
                           </span>

From 5e9cee524d9e2dd0b2ba862300b86530aac45648 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 22:23:11 +0200
Subject: [PATCH 08/61] fix(copilot): address PR review comments on
 decompose_goal tool
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add TaskDecompositionResponse to ToolResponseUnion for OpenAPI codegen
- Remove LLM-controllable require_approval param (hardcoded to True)
- Validate each step is a dict before calling .get()
- Validate step descriptions are non-empty
- Validate action values against allowlist, coerce unknown to DEFAULT_ACTION
- Align MAX_STEPS=8 with agent_generation_guide.md (was 10)
- Add DEFAULT_ACTION constant; use enum in schema
- Add model_validator to sync step_count with len(steps)
- Fix handleModify: pre-fill chat input via setInitialPrompt instead of sending dangling message
- Add approvedRef guard on handleModify to prevent double-clicks
- Fix eslint-disable: rewrite auto-approve effect without dependency suppression
- Fix hardcoded light-mode colors (bg-white, border-slate-200, text-zinc-800) → semantic tokens
- Fix error card: render ToolErrorCard whenever isError=true, not only when output is present
- Fix hint text: only show approve hint when requires_approval=true
- Remove dead `action` prop from StepItem
- Add aria-label to all StepStatusIcon states
- Tighten parseOutput type guards (Array.isArray check, no false positives)
- Rename isOperating → isPending for clarity
- Add backend unit tests for DecomposeGoalTool (16 cases)
- Add frontend unit tests for helpers.tsx (20 cases)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/api/features/chat/routes.py       |   2 +
 .../backend/copilot/tools/decompose_goal.py   |  51 ++--
 .../copilot/tools/decompose_goal_test.py      | 255 ++++++++++++++++++
 .../backend/backend/copilot/tools/models.py   |  11 +-
 .../tools/DecomposeGoal/DecomposeGoal.tsx     |  47 ++--
 .../DecomposeGoal/__tests__/helpers.test.ts   | 208 ++++++++++++++
 .../DecomposeGoal/components/StepItem.tsx     |   7 +-
 .../copilot/tools/DecomposeGoal/helpers.tsx   |  44 ++-
 8 files changed, 575 insertions(+), 50 deletions(-)
 create mode 100644 autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
 create mode 100644 autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts

diff --git a/autogpt_platform/backend/backend/api/features/chat/routes.py b/autogpt_platform/backend/backend/api/features/chat/routes.py
index 57a7b9a204ea..6288c6bda854 100644
--- a/autogpt_platform/backend/backend/api/features/chat/routes.py
+++ b/autogpt_platform/backend/backend/api/features/chat/routes.py
@@ -64,6 +64,7 @@
     NoResultsResponse,
     SetupRequirementsResponse,
     SuggestedGoalResponse,
+    TaskDecompositionResponse,
     UnderstandingUpdatedResponse,
 )
 from backend.copilot.tracking import track_user_message
@@ -1264,6 +1265,7 @@ async def health_check() -> dict:
     | DocPageResponse
     | MCPToolsDiscoveredResponse
     | MCPToolOutputResponse
+    | TaskDecompositionResponse
 )
 
 
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 598b0c597b3e..525ca1448e49 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -15,7 +15,10 @@
 
 logger = logging.getLogger(__name__)
 
-MAX_STEPS = 10
+# Matches the guide's "4-8 steps max" constraint.
+MAX_STEPS = 8
+DEFAULT_ACTION = "add_block"
+VALID_ACTIONS = {"add_block", "connect_blocks", "configure", "add_input", "add_output"}
 
 
 class DecomposeGoalTool(BaseTool):
@@ -58,6 +61,7 @@ def parameters(self) -> dict[str, Any]:
                                     "Action type: 'add_block', 'connect_blocks', "
                                     "'configure', 'add_input', 'add_output'."
                                 ),
+                                "enum": list(VALID_ACTIONS),
                             },
                             "block_name": {
                                 "type": "string",
@@ -68,11 +72,6 @@ def parameters(self) -> dict[str, Any]:
                     },
                     "description": "List of sub-instructions for the plan.",
                 },
-                "require_approval": {
-                    "type": "boolean",
-                    "description": "Whether to ask user for approval (default: true).",
-                    "default": True,
-                },
             },
             "required": ["goal", "steps"],
         }
@@ -82,8 +81,7 @@ async def _execute(
         user_id: str | None,
         session: ChatSession,
         goal: str | None = None,
-        steps: list[dict[str, Any]] | None = None,
-        require_approval: bool = True,
+        steps: list[Any] | None = None,
         **kwargs,
     ) -> ToolResponseBase:
         session_id = session.session_id if session else None
@@ -109,22 +107,39 @@ async def _execute(
                 session_id=session_id,
             )
 
-        decomposition_steps = [
-            DecompositionStepModel(
-                step_id=f"step_{i + 1}",
-                description=step.get("description", ""),
-                action=step.get("action", "add_block"),
-                block_name=step.get("block_name"),
-                status="pending",
+        decomposition_steps: list[DecompositionStepModel] = []
+        for i, step in enumerate(steps):
+            if not isinstance(step, dict):
+                return ErrorResponse(
+                    message=f"Step {i + 1} is malformed — expected an object.",
+                    error="invalid_step",
+                    session_id=session_id,
+                )
+            description = step.get("description", "")
+            if not description or not description.strip():
+                return ErrorResponse(
+                    message=f"Step {i + 1} is missing a description.",
+                    error="empty_description",
+                    session_id=session_id,
+                )
+            action = step.get("action", DEFAULT_ACTION)
+            if action not in VALID_ACTIONS:
+                action = DEFAULT_ACTION
+            decomposition_steps.append(
+                DecompositionStepModel(
+                    step_id=f"step_{i + 1}",
+                    description=description,
+                    action=action,
+                    block_name=step.get("block_name"),
+                    status="pending",
+                )
             )
-            for i, step in enumerate(steps)
-        ]
 
         return TaskDecompositionResponse(
             message=f"Here's the plan to build your agent ({len(decomposition_steps)} steps):",
             goal=goal,
             steps=decomposition_steps,
             step_count=len(decomposition_steps),
-            requires_approval=require_approval,
+            requires_approval=True,
             session_id=session_id,
         )
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
new file mode 100644
index 000000000000..0994eac13ba9
--- /dev/null
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -0,0 +1,255 @@
+"""Unit tests for DecomposeGoalTool."""
+
+import pytest
+
+from ._test_data import make_session
+from .decompose_goal import DEFAULT_ACTION, MAX_STEPS, DecomposeGoalTool
+from .models import ErrorResponse, TaskDecompositionResponse
+
+_USER_ID = "test-user-decompose-goal"
+
+_VALID_STEPS = [
+    {"description": "Add input block", "action": "add_input"},
+    {
+        "description": "Add AI summarizer block",
+        "action": "add_block",
+        "block_name": "AI Text Generator",
+    },
+    {"description": "Connect blocks together", "action": "connect_blocks"},
+]
+
+
+@pytest.fixture()
+def tool() -> DecomposeGoalTool:
+    return DecomposeGoalTool()
+
+
+@pytest.fixture()
+def session():
+    return make_session(_USER_ID)
+
+
+# ---------------------------------------------------------------------------
+# Happy path
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_happy_path(tool: DecomposeGoalTool, session):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build a news summarizer agent",
+        steps=_VALID_STEPS,
+    )
+
+    assert isinstance(result, TaskDecompositionResponse)
+    assert result.goal == "Build a news summarizer agent"
+    assert len(result.steps) == 3
+    assert result.step_count == 3
+    assert result.requires_approval is True
+    assert result.steps[0].step_id == "step_1"
+    assert result.steps[0].description == "Add input block"
+    assert result.steps[1].block_name == "AI Text Generator"
+
+
+@pytest.mark.asyncio
+async def test_step_count_matches_steps(tool: DecomposeGoalTool, session):
+    """TaskDecompositionResponse.step_count must always equal len(steps)."""
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Simple agent",
+        steps=[{"description": "Only step", "action": "add_block"}],
+    )
+    assert isinstance(result, TaskDecompositionResponse)
+    assert result.step_count == len(result.steps)
+
+
+@pytest.mark.asyncio
+async def test_requires_approval_always_true(tool: DecomposeGoalTool, session):
+    """requires_approval must always be True regardless of kwargs."""
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=_VALID_STEPS,
+        require_approval=False,  # should be ignored
+    )
+    assert isinstance(result, TaskDecompositionResponse)
+    assert result.requires_approval is True
+
+
+@pytest.mark.asyncio
+async def test_invalid_action_defaults_to_add_block(tool: DecomposeGoalTool, session):
+    """Unknown action values are coerced to DEFAULT_ACTION."""
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=[{"description": "Do something weird", "action": "fly_to_moon"}],
+    )
+    assert isinstance(result, TaskDecompositionResponse)
+    assert result.steps[0].action == DEFAULT_ACTION
+
+
+@pytest.mark.asyncio
+async def test_block_name_optional(tool: DecomposeGoalTool, session):
+    """Steps without block_name should succeed with block_name=None."""
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Agent with no block name",
+        steps=[{"description": "Configure the agent", "action": "configure"}],
+    )
+    assert isinstance(result, TaskDecompositionResponse)
+    assert result.steps[0].block_name is None
+
+
+# ---------------------------------------------------------------------------
+# Validation — missing inputs
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_missing_goal_returns_error(tool: DecomposeGoalTool, session):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal=None,
+        steps=_VALID_STEPS,
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "missing_goal"
+
+
+@pytest.mark.asyncio
+async def test_empty_goal_returns_error(tool: DecomposeGoalTool, session):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="",
+        steps=_VALID_STEPS,
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "missing_goal"
+
+
+@pytest.mark.asyncio
+async def test_missing_steps_returns_error(tool: DecomposeGoalTool, session):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=None,
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "missing_steps"
+
+
+@pytest.mark.asyncio
+async def test_empty_steps_returns_error(tool: DecomposeGoalTool, session):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=[],
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "missing_steps"
+
+
+@pytest.mark.asyncio
+async def test_too_many_steps_returns_error(tool: DecomposeGoalTool, session):
+    many_steps = [
+        {"description": f"Step {i}", "action": "add_block"}
+        for i in range(MAX_STEPS + 1)
+    ]
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Over-engineered agent",
+        steps=many_steps,
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "too_many_steps"
+
+
+@pytest.mark.asyncio
+async def test_exactly_max_steps_succeeds(tool: DecomposeGoalTool, session):
+    """Exactly MAX_STEPS steps should succeed."""
+    max_steps = [
+        {"description": f"Step {i}", "action": "add_block"} for i in range(MAX_STEPS)
+    ]
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Complex agent",
+        steps=max_steps,
+    )
+    assert isinstance(result, TaskDecompositionResponse)
+    assert len(result.steps) == MAX_STEPS
+
+
+# ---------------------------------------------------------------------------
+# Validation — malformed step items
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_non_dict_step_returns_error(tool: DecomposeGoalTool, session):
+    """A step that is not a dict should return an error."""
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=["not a dict"],  # type: ignore[list-item]
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "invalid_step"
+
+
+@pytest.mark.asyncio
+async def test_step_with_empty_description_returns_error(
+    tool: DecomposeGoalTool, session
+):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=[{"description": "", "action": "add_block"}],
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "empty_description"
+
+
+@pytest.mark.asyncio
+async def test_step_with_missing_description_returns_error(
+    tool: DecomposeGoalTool, session
+):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=[{"action": "add_block"}],
+    )
+    assert isinstance(result, ErrorResponse)
+    assert result.error == "empty_description"
+
+
+# ---------------------------------------------------------------------------
+# ID generation
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_step_ids_are_sequential(tool: DecomposeGoalTool, session):
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=_VALID_STEPS,
+    )
+    assert isinstance(result, TaskDecompositionResponse)
+    for i, step in enumerate(result.steps):
+        assert step.step_id == f"step_{i + 1}"
diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.py
index 6c65764469c2..6d6db28482f5 100644
--- a/autogpt_platform/backend/backend/copilot/tools/models.py
+++ b/autogpt_platform/backend/backend/copilot/tools/models.py
@@ -4,7 +4,7 @@
 from enum import Enum
 from typing import Any, Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 from backend.data.graph import BaseGraph
 from backend.data.model import CredentialsMetaInput
@@ -719,7 +719,12 @@ class TaskDecompositionResponse(ToolResponseBase):
     type: ResponseType = ResponseType.TASK_DECOMPOSITION
     goal: str = Field(description="The original user goal")
     steps: list[DecompositionStepModel]
-    step_count: int
+    step_count: int = Field(
+        default=0, description="Number of steps (auto-derived from steps list)"
+    )
     requires_approval: bool = True
 
-
+    @model_validator(mode="after")
+    def sync_step_count(self) -> "TaskDecompositionResponse":
+        self.step_count = len(self.steps)
+        return self
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index dbab6ddd7ec1..442f979cbc44 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -17,6 +17,7 @@ import {
 } from "../../components/ToolAccordion/AccordionContent";
 import { ToolAccordion } from "../../components/ToolAccordion/ToolAccordion";
 import { ToolErrorCard } from "../../components/ToolErrorCard/ToolErrorCard";
+import { useCopilotUIStore } from "../../store";
 import { StepItem } from "./components/StepItem";
 import {
   AccordionIcon,
@@ -47,6 +48,7 @@ interface Props {
 export function DecomposeGoalTool({ part, isLastMessage }: Props) {
   const text = getAnimationText(part);
   const { onSend } = useCopilotChatActions();
+  const { setInitialPrompt } = useCopilotUIStore();
 
   const isStreaming =
     part.state === "input-streaming" || part.state === "input-available";
@@ -54,7 +56,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
   const output = getDecomposeGoalOutput(part);
   const isError =
     part.state === "output-error" || (!!output && isErrorOutput(output));
-  const isOperating = !output;
+  const isPending = !output;
 
   const showActions =
     !!isLastMessage &&
@@ -94,10 +96,12 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
   }
 
   function handleModify() {
+    if (approvedRef.current) return;
     if (!output || !isDecompositionOutput(output)) return;
     setTimerActive(false);
     setIsEditing(true);
     setEditableSteps(output.steps.map((s) => ({ ...s })));
+    setInitialPrompt("I'd like to modify the plan. Here are my changes: ");
   }
 
   function handleStepChange(index: number, description: string) {
@@ -134,11 +138,13 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
   }, [showActions, timerActive, part.toolCallId]);
 
   // Auto-approve when countdown reaches 0 (only if timer is still active).
+  // approve() is stable via approvedRef — timerActive is captured in the condition
+  // so the effect re-runs whenever timerActive changes, preventing stale closure issues.
   useEffect(() => {
-    if (secondsLeft === 0 && timerActive) approve();
-    // approve is stable via ref — intentionally omitted
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [secondsLeft, timerActive]);
+    if (secondsLeft === 0 && timerActive) {
+      approve();
+    }
+  }, [secondsLeft, timerActive]); // approve reads refs only — safe to omit
 
   const progress = secondsLeft / COUNTDOWN_SECONDS;
   const dashOffset = CIRCUMFERENCE * (1 - progress);
@@ -150,7 +156,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
 
   return (
     <div className="py-2">
-      {isOperating && (
+      {isPending && (
         <div className="flex items-center gap-2 text-sm text-muted-foreground">
           <ToolIcon isStreaming={isStreaming} isError={isError} />
           <MorphingTextAnimation
@@ -160,9 +166,11 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
         </div>
       )}
 
-      {isError && output && isErrorOutput(output) && (
+      {isError && (
         <ToolErrorCard
-          message={output.message ?? ""}
+          message={
+            output && isErrorOutput(output) ? (output.message ?? "") : ""
+          }
           fallbackMessage="Failed to analyze the goal. Please try again."
           actions={[
             {
@@ -183,7 +191,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
           <ContentGrid>
             <ContentMessage>{output.message}</ContentMessage>
 
-            <div className="rounded-lg border border-slate-200 bg-white p-3">
+            <div className="rounded-lg border border-border bg-card p-3">
               {isEditing ? (
                 <div className="flex flex-col">
                   {/* Insert before the first step */}
@@ -192,7 +200,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                   {editableSteps.map((step, i) => (
                     <div key={step.step_id} className="flex flex-col">
                       <div className="flex items-start gap-2 py-1">
-                        <span className="w-5 shrink-0 pt-1 text-xs text-slate-400">
+                        <span className="w-5 shrink-0 pt-1 text-xs text-muted-foreground">
                           {i + 1}.
                         </span>
                         <textarea
@@ -205,13 +213,13 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                           value={step.description}
                           onChange={(e) => handleStepChange(i, e.target.value)}
                           rows={1}
-                          className="flex-1 resize-none overflow-hidden rounded border border-slate-200 px-2 py-1 text-sm focus:border-neutral-400 focus:outline-none"
+                          className="flex-1 resize-none overflow-hidden rounded border border-border px-2 py-1 text-sm focus:border-neutral-400 focus:outline-none"
                           placeholder="Step description"
                         />
                         <button
                           type="button"
                           onClick={() => handleStepDelete(i)}
-                          className="mt-1 text-slate-400 hover:text-red-500"
+                          className="mt-1 text-muted-foreground hover:text-red-500"
                           aria-label="Remove step"
                         >
                           <TrashIcon size={14} />
@@ -229,7 +237,6 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                       key={step.step_id}
                       index={i}
                       description={step.description}
-                      action={step.action}
                       blockName={step.block_name}
                       status={step.status}
                     />
@@ -283,7 +290,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                                 className="text-neutral-600 transition-[stroke-dashoffset] duration-1000 ease-linear"
                               />
                             </svg>
-                            <span className="relative z-10 text-[11px] font-semibold tabular-nums text-neutral-700">
+                            <span className="relative z-10 text-[11px] font-semibold tabular-nums text-foreground">
                               {secondsLeft}
                             </span>
                           </span>
@@ -305,6 +312,12 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                 )}
               </div>
             )}
+
+            {output.requires_approval && !showActions && (
+              <ContentMessage>
+                Review the plan above and approve to start building.
+              </ContentMessage>
+            )}
           </ContentGrid>
         </ToolAccordion>
       )}
@@ -315,16 +328,16 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
 function InsertButton({ onClick }: { onClick: () => void }) {
   return (
     <div className="group flex items-center gap-1 py-0.5">
-      <div className="h-px flex-1 bg-slate-100 group-hover:bg-neutral-300" />
+      <div className="h-px flex-1 bg-border group-hover:bg-neutral-300" />
       <button
         type="button"
         onClick={onClick}
-        className="flex items-center gap-0.5 rounded px-1 text-xs text-slate-300 hover:text-neutral-700 focus:outline-none"
+        className="flex items-center gap-0.5 rounded px-1 text-xs text-muted-foreground hover:text-foreground focus:outline-none"
         aria-label="Insert step here"
       >
         <PlusIcon size={10} weight="bold" />
       </button>
-      <div className="h-px flex-1 bg-slate-100 group-hover:bg-neutral-300" />
+      <div className="h-px flex-1 bg-border group-hover:bg-neutral-300" />
     </div>
   );
 }
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
new file mode 100644
index 000000000000..80c9f835adeb
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
@@ -0,0 +1,208 @@
+/**
+ * Unit tests for DecomposeGoal/helpers.tsx
+ *
+ * Covers: parseOutput / getDecomposeGoalOutput, type guards, getAnimationText
+ */
+
+import { describe, expect, it } from "vitest";
+import {
+  getAnimationText,
+  getDecomposeGoalOutput,
+  isDecompositionOutput,
+  isErrorOutput,
+  type DecomposeErrorOutput,
+  type DecomposeGoalOutput,
+  type TaskDecompositionOutput,
+} from "../helpers";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const DECOMPOSITION: TaskDecompositionOutput = {
+  type: "task_decomposition",
+  message: "Here's the plan (3 steps):",
+  goal: "Build a news summarizer",
+  steps: [
+    {
+      step_id: "step_1",
+      description: "Add input block",
+      action: "add_input",
+      block_name: null,
+      status: "pending",
+    },
+    {
+      step_id: "step_2",
+      description: "Add AI summarizer",
+      action: "add_block",
+      block_name: "AI Text Generator",
+      status: "pending",
+    },
+    {
+      step_id: "step_3",
+      description: "Connect blocks",
+      action: "connect_blocks",
+      block_name: null,
+      status: "pending",
+    },
+  ],
+  step_count: 3,
+  requires_approval: true,
+};
+
+const ERROR_OUTPUT: DecomposeErrorOutput = {
+  type: "error",
+  error: "missing_steps",
+  message: "Please provide at least one step.",
+};
+
+// ---------------------------------------------------------------------------
+// isDecompositionOutput
+// ---------------------------------------------------------------------------
+
+describe("isDecompositionOutput", () => {
+  it("returns true for a full decomposition output", () => {
+    expect(isDecompositionOutput(DECOMPOSITION)).toBe(true);
+  });
+
+  it("returns false for an error output", () => {
+    expect(
+      isDecompositionOutput(ERROR_OUTPUT as unknown as DecomposeGoalOutput),
+    ).toBe(false);
+  });
+
+  it("returns false when steps is not an array (type guard tightness)", () => {
+    const malformed = {
+      steps: "not-an-array",
+      goal: "test",
+    } as unknown as DecomposeGoalOutput;
+    expect(isDecompositionOutput(malformed)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isErrorOutput
+// ---------------------------------------------------------------------------
+
+describe("isErrorOutput", () => {
+  it("returns true for error output", () => {
+    expect(isErrorOutput(ERROR_OUTPUT as unknown as DecomposeGoalOutput)).toBe(
+      true,
+    );
+  });
+
+  it("returns false for decomposition output", () => {
+    expect(isErrorOutput(DECOMPOSITION)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getDecomposeGoalOutput — output parsing
+// ---------------------------------------------------------------------------
+
+describe("getDecomposeGoalOutput", () => {
+  it("parses a direct object output", () => {
+    const part = { output: DECOMPOSITION };
+    const result = getDecomposeGoalOutput(part);
+    expect(result).not.toBeNull();
+    expect(isDecompositionOutput(result!)).toBe(true);
+  });
+
+  it("parses a JSON-encoded string output", () => {
+    const part = { output: JSON.stringify(DECOMPOSITION) };
+    const result = getDecomposeGoalOutput(part);
+    expect(result).not.toBeNull();
+    expect(isDecompositionOutput(result!)).toBe(true);
+    expect((result as TaskDecompositionOutput).goal).toBe(
+      "Build a news summarizer",
+    );
+  });
+
+  it("parses an error output object", () => {
+    const part = { output: ERROR_OUTPUT };
+    const result = getDecomposeGoalOutput(part);
+    expect(result).not.toBeNull();
+    expect(isErrorOutput(result!)).toBe(true);
+  });
+
+  it("returns null for falsy output", () => {
+    expect(getDecomposeGoalOutput({ output: null })).toBeNull();
+    expect(getDecomposeGoalOutput({ output: undefined })).toBeNull();
+    expect(getDecomposeGoalOutput({ output: "" })).toBeNull();
+  });
+
+  it("returns null for a plain non-JSON string", () => {
+    expect(getDecomposeGoalOutput({ output: "just text" })).toBeNull();
+  });
+
+  it("returns null for a non-object part", () => {
+    expect(getDecomposeGoalOutput(null)).toBeNull();
+    expect(getDecomposeGoalOutput("string")).toBeNull();
+    expect(getDecomposeGoalOutput(42)).toBeNull();
+  });
+
+  it("returns null for an array-type output (not a valid shape)", () => {
+    expect(
+      getDecomposeGoalOutput({ output: ["not", "an", "object"] }),
+    ).toBeNull();
+  });
+
+  it("classifies 'steps+goal' before 'error' when object has all three keys", () => {
+    // Verify type discrimination precedence: steps+goal wins
+    const mixed = { ...DECOMPOSITION, error: "some_error" };
+    const part = { output: mixed };
+    const result = getDecomposeGoalOutput(part);
+    expect(result).not.toBeNull();
+    expect(isDecompositionOutput(result!)).toBe(true);
+  });
+
+  it("returns message-only error when no error key but has message", () => {
+    const messageOnly = { type: "error", message: "Something failed" };
+    const result = getDecomposeGoalOutput({ output: messageOnly });
+    expect(result).not.toBeNull();
+    // isErrorOutput requires 'error' key, so this falls through to message-only branch
+    expect((result as DecomposeErrorOutput).message).toBe("Something failed");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getAnimationText
+// ---------------------------------------------------------------------------
+
+describe("getAnimationText", () => {
+  it("shows analyzing text during input-streaming", () => {
+    const text = getAnimationText({ state: "input-streaming" });
+    expect(text.toLowerCase()).toContain("analyzing");
+  });
+
+  it("shows analyzing text during input-available", () => {
+    const text = getAnimationText({ state: "input-available" });
+    expect(text.toLowerCase()).toContain("analyzing");
+  });
+
+  it("shows plan ready with step count on output-available with decomposition", () => {
+    const text = getAnimationText({
+      state: "output-available",
+      output: DECOMPOSITION,
+    });
+    expect(text).toContain("3 steps");
+  });
+
+  it("shows analyzing when output-available but output is not a decomposition", () => {
+    const text = getAnimationText({
+      state: "output-available",
+      output: null,
+    });
+    expect(text.toLowerCase()).toContain("analyzing");
+  });
+
+  it("shows error text on output-error state", () => {
+    const text = getAnimationText({ state: "output-error" });
+    expect(text.toLowerCase()).toContain("error");
+  });
+
+  it("falls back to analyzing for unknown state", () => {
+    const text = getAnimationText({ state: "result" as never });
+    expect(text.toLowerCase()).toContain("analyzing");
+  });
+});
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx
index ac1305e70674..cb4f9810a38d 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/StepItem.tsx
@@ -7,7 +7,6 @@ import { StepStatusIcon } from "../helpers";
 interface Props {
   index: number;
   description: string;
-  action: string;
   blockName?: string | null;
   status: string;
 }
@@ -19,15 +18,15 @@ export function StepItem({ index, description, blockName, status }: Props) {
         <StepStatusIcon status={status} />
       </div>
       <div className="min-w-0 flex-1">
-        <Text variant="body-medium" className="text-sm text-zinc-800">
+        <Text variant="body-medium" className="text-sm text-foreground">
           {index + 1}. {description}
         </Text>
         {blockName && (
           <div className="mt-0.5 flex items-center gap-1">
-            <CubeIcon size={12} className="text-neutral-400" />
+            <CubeIcon size={12} className="text-muted-foreground" />
             <Text
               variant="small"
-              className="font-mono text-xs text-neutral-500"
+              className="font-mono text-xs text-muted-foreground"
             >
               {blockName}
             </Text>
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
index ac1111d1e6b4..4cfdec576bb2 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -49,12 +49,22 @@ function parseOutput(output: unknown): DecomposeGoalOutput | null {
       return null;
     }
   }
-  if (typeof output === "object") {
-    if ("steps" in output && "goal" in output) {
-      return output as TaskDecompositionOutput;
+  if (typeof output === "object" && !Array.isArray(output)) {
+    const obj = output as Record<string, unknown>;
+    if (
+      "steps" in obj &&
+      "goal" in obj &&
+      Array.isArray(obj.steps) &&
+      typeof obj.goal === "string"
+    ) {
+      return obj as unknown as TaskDecompositionOutput;
     }
-    if ("error" in output) {
-      return output as DecomposeErrorOutput;
+    if ("error" in obj && typeof obj.error === "string") {
+      return obj as unknown as DecomposeErrorOutput;
+    }
+    // Message-only error payload (no 'error' key but also not a decomposition)
+    if ("message" in obj && typeof obj.message === "string") {
+      return obj as unknown as DecomposeErrorOutput;
     }
   }
   return null;
@@ -70,7 +80,11 @@ export function getDecomposeGoalOutput(
 export function isDecompositionOutput(
   output: DecomposeGoalOutput,
 ): output is TaskDecompositionOutput {
-  return "steps" in output && "goal" in output;
+  return (
+    "steps" in output &&
+    Array.isArray((output as TaskDecompositionOutput).steps) &&
+    "goal" in output
+  );
 }
 
 export function isErrorOutput(
@@ -128,7 +142,12 @@ export function StepStatusIcon({ status }: { status: string }) {
   switch (status) {
     case "completed":
       return (
-        <CheckCircleIcon size={18} weight="fill" className="text-emerald-500" />
+        <CheckCircleIcon
+          size={18}
+          weight="fill"
+          className="text-emerald-500"
+          aria-label="completed"
+        />
       );
     case "in_progress":
       return (
@@ -136,16 +155,25 @@ export function StepStatusIcon({ status }: { status: string }) {
           size={18}
           weight="bold"
           className="animate-spin text-blue-500"
+          aria-label="in progress"
         />
       );
     case "failed":
-      return <XCircleIcon size={18} weight="fill" className="text-red-500" />;
+      return (
+        <XCircleIcon
+          size={18}
+          weight="fill"
+          className="text-red-500"
+          aria-label="failed"
+        />
+      );
     default:
       return (
         <CircleDashedIcon
           size={18}
           weight="regular"
           className="text-neutral-400"
+          aria-label="pending"
         />
       );
   }

From 9004a3ada11d508cc7f357add21aa87d1568d2d7 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 22:25:27 +0200
Subject: [PATCH 09/61] fix(copilot): guard auto-approve against race condition
 when isLastMessage changes

Add showActions to the auto-approve useEffect dependency array and
condition. This prevents the approval from firing after isLastMessage
becomes false (e.g. when a new message arrives just as the timer
expires), closing the race condition flagged by Sentry.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/tools/DecomposeGoal/DecomposeGoal.tsx      | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 442f979cbc44..41f348e97407 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -137,14 +137,14 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     return () => clearInterval(interval);
   }, [showActions, timerActive, part.toolCallId]);
 
-  // Auto-approve when countdown reaches 0 (only if timer is still active).
-  // approve() is stable via approvedRef — timerActive is captured in the condition
-  // so the effect re-runs whenever timerActive changes, preventing stale closure issues.
+  // Auto-approve when countdown reaches 0 (only if timer is still active and actions visible).
+  // showActions prevents firing after isLastMessage changes (race condition guard).
+  // approve() is stable via approvedRef — safe to omit from deps.
   useEffect(() => {
-    if (secondsLeft === 0 && timerActive) {
+    if (secondsLeft === 0 && timerActive && showActions) {
       approve();
     }
-  }, [secondsLeft, timerActive]); // approve reads refs only — safe to omit
+  }, [secondsLeft, timerActive, showActions]); // approve reads refs only — safe to omit
 
   const progress = secondsLeft / COUNTDOWN_SECONDS;
   const dashOffset = CIRCUMFERENCE * (1 - progress);

From 70689ce32605fbcae4aaa286575f9427fa2d7fd0 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 22:40:39 +0200
Subject: [PATCH 10/61] fix(frontend/copilot): guard isPending flag on error
 and filter empty steps from approval

- Prevent simultaneous pending + error state when output-error has null payload:
  isPending is now false when isError is true
- Filter out steps with empty descriptions before building the approval
  message, preventing malformed input from reaching the LLM

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/tools/DecomposeGoal/DecomposeGoal.tsx          | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 41f348e97407..d55304a4ceda 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -56,7 +56,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
   const output = getDecomposeGoalOutput(part);
   const isError =
     part.state === "output-error" || (!!output && isErrorOutput(output));
-  const isPending = !output;
+  const isPending = !output && !isError;
 
   const showActions =
     !!isLastMessage &&
@@ -80,7 +80,10 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
 
   function buildMessage() {
     if (isEditingRef.current && editableStepsRef.current.length > 0) {
-      const list = editableStepsRef.current
+      const filledSteps = editableStepsRef.current.filter((s) =>
+        s.description.trim(),
+      );
+      const list = filledSteps
         .map((s, i) => `${i + 1}. ${s.description}`)
         .join("; ");
       return `Approved with modifications. Please build the agent following these steps: ${list}`;

From 02b972cfc4923c9cd80bffa3e6b35bcfcd80540c Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 22:51:18 +0200
Subject: [PATCH 11/61] fix(backend/copilot): regenerate openapi.json with
 TaskDecompositionResponse schema

The API schema was missing DecompositionStepModel and TaskDecompositionResponse
after the merge. Regenerated with export-api-schema and formatted with prettier.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../frontend/src/app/api/openapi.json         | 75 ++++++++++++++++++-
 1 file changed, 74 insertions(+), 1 deletion(-)

diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 8dd9b5587fc3..de5c6fc2ed9c 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -1163,7 +1163,8 @@
                     {
                       "$ref": "#/components/schemas/MCPToolsDiscoveredResponse"
                     },
-                    { "$ref": "#/components/schemas/MCPToolOutputResponse" }
+                    { "$ref": "#/components/schemas/MCPToolOutputResponse" },
+                    { "$ref": "#/components/schemas/TaskDecompositionResponse" }
                   ],
                   "title": "Response Getv2[Dummy] Tool Response Type Export For Codegen"
                 }
@@ -9212,6 +9213,40 @@
         "enum": ["TOP_UP", "USAGE", "GRANT", "REFUND", "CARD_CHECK"],
         "title": "CreditTransactionType"
       },
+      "DecompositionStepModel": {
+        "properties": {
+          "step_id": {
+            "type": "string",
+            "title": "Step Id",
+            "description": "Unique step identifier, e.g. 'step_1'"
+          },
+          "description": {
+            "type": "string",
+            "title": "Description",
+            "description": "Human-readable step description"
+          },
+          "action": {
+            "type": "string",
+            "title": "Action",
+            "description": "Action type: 'add_block', 'connect_blocks', 'configure', etc."
+          },
+          "block_name": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Block Name",
+            "description": "Block being added, if applicable"
+          },
+          "status": {
+            "type": "string",
+            "title": "Status",
+            "description": "Step status: pending, in_progress, completed, failed",
+            "default": "pending"
+          }
+        },
+        "type": "object",
+        "required": ["step_id", "description", "action"],
+        "title": "DecompositionStepModel",
+        "description": "A single step in a decomposed agent-building plan."
+      },
       "DeleteFileResponse": {
         "properties": { "deleted": { "type": "boolean", "title": "Deleted" } },
         "type": "object",
@@ -13722,6 +13757,44 @@
         "required": ["recent_searches", "providers", "top_blocks"],
         "title": "SuggestionsResponse"
       },
+      "TaskDecompositionResponse": {
+        "properties": {
+          "type": {
+            "$ref": "#/components/schemas/ResponseType",
+            "default": "task_decomposition"
+          },
+          "message": { "type": "string", "title": "Message" },
+          "session_id": {
+            "anyOf": [{ "type": "string" }, { "type": "null" }],
+            "title": "Session Id"
+          },
+          "goal": {
+            "type": "string",
+            "title": "Goal",
+            "description": "The original user goal"
+          },
+          "steps": {
+            "items": { "$ref": "#/components/schemas/DecompositionStepModel" },
+            "type": "array",
+            "title": "Steps"
+          },
+          "step_count": {
+            "type": "integer",
+            "title": "Step Count",
+            "description": "Number of steps (auto-derived from steps list)",
+            "default": 0
+          },
+          "requires_approval": {
+            "type": "boolean",
+            "title": "Requires Approval",
+            "default": true
+          }
+        },
+        "type": "object",
+        "required": ["message", "goal", "steps"],
+        "title": "TaskDecompositionResponse",
+        "description": "Response for decompose_goal tool — shows the plan to the user."
+      },
       "TimezoneResponse": {
         "properties": {
           "timezone": {

From 8d5e8a9e3fab9e94092dcda90baad43d32c57e5e Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 23:09:14 +0200
Subject: [PATCH 12/61] fix(backend/copilot): add decompose_goal to ToolName
 Literal in permissions.py

The ToolName Literal must stay in sync with TOOL_REGISTRY keys. Adds
'decompose_goal' to the platform tools section to fix CI test failures.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 autogpt_platform/backend/backend/copilot/permissions.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/autogpt_platform/backend/backend/copilot/permissions.py b/autogpt_platform/backend/backend/copilot/permissions.py
index b201840cc9ee..841d52bfaf38 100644
--- a/autogpt_platform/backend/backend/copilot/permissions.py
+++ b/autogpt_platform/backend/backend/copilot/permissions.py
@@ -77,6 +77,7 @@
     "create_feature_request",
     "create_folder",
     "customize_agent",
+    "decompose_goal",
     "delete_folder",
     "delete_workspace_file",
     "edit_agent",

From 94f065a7e0a848f701d6c9bb10ce0f54e1711e6f Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 9 Apr 2026 23:15:16 +0200
Subject: [PATCH 13/61] fix(frontend/copilot): remove setInitialPrompt conflict
 and reset edit mode on new message
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Remove setInitialPrompt() from handleModify() — the inline editor is the
  sole editing UX; pre-filling the chat input simultaneously creates a
  conflicting interface where chat-input submission loses inline edits
- Add useEffect to reset isEditing when showActions goes false (new message
  arrives while editing), preventing users from being stuck in edit mode with
  no way to submit

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/tools/DecomposeGoal/DecomposeGoal.tsx      | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index d55304a4ceda..74082a8277da 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -17,7 +17,6 @@ import {
 } from "../../components/ToolAccordion/AccordionContent";
 import { ToolAccordion } from "../../components/ToolAccordion/ToolAccordion";
 import { ToolErrorCard } from "../../components/ToolErrorCard/ToolErrorCard";
-import { useCopilotUIStore } from "../../store";
 import { StepItem } from "./components/StepItem";
 import {
   AccordionIcon,
@@ -48,7 +47,6 @@ interface Props {
 export function DecomposeGoalTool({ part, isLastMessage }: Props) {
   const text = getAnimationText(part);
   const { onSend } = useCopilotChatActions();
-  const { setInitialPrompt } = useCopilotUIStore();
 
   const isStreaming =
     part.state === "input-streaming" || part.state === "input-available";
@@ -104,7 +102,6 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     setTimerActive(false);
     setIsEditing(true);
     setEditableSteps(output.steps.map((s) => ({ ...s })));
-    setInitialPrompt("I'd like to modify the plan. Here are my changes: ");
   }
 
   function handleStepChange(index: number, description: string) {
@@ -131,6 +128,13 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     });
   }
 
+  // If a new message arrives while editing, exit edit mode so the user is not stuck.
+  useEffect(() => {
+    if (!showActions && isEditing) {
+      setIsEditing(false);
+    }
+  }, [showActions, isEditing]);
+
   // Tick down only while the timer is active.
   useEffect(() => {
     if (!showActions || !timerActive) return;

From fb86fcb67dc2f63d787e28d2ce403e8c6418d5e9 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 10 Apr 2026 16:34:46 +0200
Subject: [PATCH 14/61] feat(copilot): add server-side auto-approve fallback
 for decompose_goal

The decompose_goal countdown was purely client-side: if the user closed the
tab before the timer ran out, the agent never got built. Add a server-side
timer that fires the same approval message even when no client is connected.

- backend/copilot/model.py: add append_message_if helper that appends a
  message inside the session lock only if a predicate is satisfied. Used
  by the auto-approve task to no-op when the user has already acted.
- backend/copilot/tools/decompose_goal.py: when the tool returns, schedule
  a fire-and-forget asyncio task (same _background_tasks pattern as
  agent_browser.py) that sleeps 90s, re-checks the session, and if no user
  message has appeared since, appends "Approved. Please build the agent."
  and enqueues a new copilot turn. Stays in process; restart-resilience
  is a documented follow-up.
- backend/copilot/tools/models.py: expose auto_approve_seconds on
  TaskDecompositionResponse so the frontend countdown is sourced from the
  backend instead of a hard-coded constant.
- frontend DecomposeGoal.tsx: seed secondsLeft from output.auto_approve_seconds
  with a 60s fallback for older sessions.
- Regenerate openapi.json with the new field.
- Tests: 9 new unit tests covering the predicate, the auto-approve flow
  (idle / user-acted / errors swallowed) and _schedule_auto_approve.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/backend/copilot/model.py          |  45 +++-
 .../backend/copilot/tools/decompose_goal.py   | 112 ++++++++-
 .../copilot/tools/decompose_goal_test.py      | 236 +++++++++++++++++-
 .../backend/backend/copilot/tools/models.py   |   8 +
 .../tools/DecomposeGoal/DecomposeGoal.tsx     |  32 ++-
 .../copilot/tools/DecomposeGoal/helpers.tsx   |   1 +
 .../frontend/src/app/api/openapi.json         |   6 +
 7 files changed, 424 insertions(+), 16 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/model.py b/autogpt_platform/backend/backend/copilot/model.py
index 9bb7964b9399..4fc703063fd5 100644
--- a/autogpt_platform/backend/backend/copilot/model.py
+++ b/autogpt_platform/backend/backend/copilot/model.py
@@ -2,7 +2,7 @@
 import logging
 import uuid
 from datetime import UTC, datetime
-from typing import Any, Self, cast
+from typing import Any, Callable, Self, cast
 from weakref import WeakValueDictionary
 
 from openai.types.chat import (
@@ -677,6 +677,49 @@ async def append_and_save_message(session_id: str, message: ChatMessage) -> Chat
         return session
 
 
+async def append_message_if(
+    session_id: str,
+    message: ChatMessage,
+    predicate: Callable[["ChatSession"], bool],
+) -> "ChatSession | None":
+    """Atomically append a message iff ``predicate(session)`` returns True.
+
+    Used by fire-and-forget tasks that need to no-op if the session state
+    has moved on while they were waiting (e.g. the decompose_goal server-side
+    auto-approve timer: skip the approval if the user has already sent a
+    message). The predicate runs inside the session lock, so the check and
+    the append are one atomic operation — no race with concurrent appends.
+
+    Returns the updated session on append, or ``None`` if the predicate
+    rejected, the session no longer exists, or the append failed.
+    """
+    lock = await _get_session_lock(session_id)
+
+    async with lock:
+        session = await get_chat_session(session_id)
+        if session is None or not predicate(session):
+            return None
+
+        session.messages.append(message)
+        existing_message_count = await chat_db().get_next_sequence(session_id)
+
+        try:
+            await _save_session_to_db(session, existing_message_count)
+        except Exception as e:
+            logger.error(
+                f"append_message_if: failed to persist message to "
+                f"session {session_id}: {e}"
+            )
+            return None
+
+        try:
+            await cache_chat_session(session)
+        except Exception as e:
+            logger.warning(f"Cache write failed for session {session_id}: {e}")
+
+        return session
+
+
 async def create_chat_session(user_id: str, *, dry_run: bool) -> ChatSession:
     """Create a new chat session and persist it.
 
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 525ca1448e49..8c143c928d42 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -1,9 +1,11 @@
 """DecomposeGoalTool - Breaks agent-building goals into sub-instructions."""
 
+import asyncio
 import logging
 from typing import Any
+from uuid import uuid4
 
-from backend.copilot.model import ChatSession
+from backend.copilot.model import ChatMessage, ChatSession, append_message_if
 
 from .base import BaseTool
 from .models import (
@@ -20,6 +22,111 @@
 DEFAULT_ACTION = "add_block"
 VALID_ACTIONS = {"add_block", "connect_blocks", "configure", "add_input", "add_output"}
 
+# Auto-approve countdown — single source of truth for both client and server.
+# The frontend reads ``auto_approve_seconds`` from the tool response and runs
+# the visible countdown. The server fallback runs slightly longer to absorb
+# network latency / SSE round-trip when the client also sends "Approved".
+AUTO_APPROVE_CLIENT_SECONDS = 60
+AUTO_APPROVE_SERVER_GRACE_SECONDS = 30
+AUTO_APPROVE_SERVER_SECONDS = (
+    AUTO_APPROVE_CLIENT_SECONDS + AUTO_APPROVE_SERVER_GRACE_SECONDS
+)
+AUTO_APPROVE_MESSAGE = "Approved. Please build the agent."
+
+# Fire-and-forget tasks held to keep them alive and self-clean on completion.
+# Same pattern as ``backend/copilot/tools/agent_browser.py``.
+_auto_approve_tasks: set[asyncio.Task] = set()
+
+
+def _no_user_action_since(baseline_sequence: int):
+    """Predicate: returns True iff no user message has been appended after
+    the message at ``baseline_sequence``."""
+
+    def _check(session: ChatSession) -> bool:
+        for m in session.messages:
+            if m.role == "user" and (m.sequence or 0) > baseline_sequence:
+                return False
+        return True
+
+    return _check
+
+
+async def _run_auto_approve(
+    session_id: str,
+    user_id: str | None,
+    baseline_sequence: int,
+) -> None:
+    """Wait the server-side timeout and inject a synthetic approval if the
+    user has not acted in the meantime.
+
+    Limitation: this lives in the executor process; if the worker restarts
+    during the wait, the pending approval is lost (the user falls back to
+    manual approve). Restart-resilience would need a Redis-backed scheduler.
+
+    Modify-mode caveat: clicking "Modify" stops the *client* timer, not this
+    one. Users have ``AUTO_APPROVE_SERVER_SECONDS`` total to finish editing
+    and click Approve, otherwise the server fires the default approval. A
+    follow-up should add an explicit cancel endpoint.
+    """
+    try:
+        await asyncio.sleep(AUTO_APPROVE_SERVER_SECONDS)
+
+        approval = ChatMessage(role="user", content=AUTO_APPROVE_MESSAGE)
+        result = await append_message_if(
+            session_id=session_id,
+            message=approval,
+            predicate=_no_user_action_since(baseline_sequence),
+        )
+        if result is None:
+            # User already acted (or the session is gone) — nothing to do.
+            return
+
+        # Local imports avoid a circular dependency between this module and
+        # the executor / API stream registry packages.
+        from backend.copilot import stream_registry
+        from backend.copilot.executor.utils import enqueue_copilot_turn
+
+        turn_id = str(uuid4())
+        await stream_registry.create_session(
+            session_id=session_id,
+            user_id=user_id or "",
+            tool_call_id="chat_stream",
+            tool_name="chat",
+            turn_id=turn_id,
+        )
+        await enqueue_copilot_turn(
+            session_id=session_id,
+            user_id=user_id,
+            message=AUTO_APPROVE_MESSAGE,
+            turn_id=turn_id,
+            is_user_message=True,
+        )
+        logger.info("decompose_goal auto-approve fired for session %s", session_id)
+    except asyncio.CancelledError:
+        raise
+    except Exception:
+        logger.exception(
+            "decompose_goal auto-approve task failed for session %s",
+            session_id,
+        )
+
+
+def _schedule_auto_approve(
+    session_id: str | None, user_id: str | None, session: ChatSession
+) -> None:
+    """Schedule the fire-and-forget auto-approve task for this session."""
+    if not session_id:
+        return
+    baseline_sequence = max(
+        (m.sequence or 0 for m in session.messages),
+        default=0,
+    )
+    task = asyncio.create_task(
+        _run_auto_approve(session_id, user_id, baseline_sequence)
+    )
+    _auto_approve_tasks.add(task)
+    task.add_done_callback(_auto_approve_tasks.discard)
+
 
 class DecomposeGoalTool(BaseTool):
     """Tool for decomposing an agent goal into sub-instructions."""
@@ -135,11 +242,14 @@ async def _execute(
                 )
             )
 
+        _schedule_auto_approve(session_id, user_id, session)
+
         return TaskDecompositionResponse(
             message=f"Here's the plan to build your agent ({len(decomposition_steps)} steps):",
             goal=goal,
             steps=decomposition_steps,
             step_count=len(decomposition_steps),
             requires_approval=True,
+            auto_approve_seconds=AUTO_APPROVE_CLIENT_SECONDS,
             session_id=session_id,
         )
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index 0994eac13ba9..50984bc58ff8 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -1,11 +1,26 @@
 """Unit tests for DecomposeGoalTool."""
 
+import asyncio
+from unittest.mock import AsyncMock, patch
+
 import pytest
 
+from backend.copilot.model import ChatMessage
+
+from . import decompose_goal as decompose_goal_module
 from ._test_data import make_session
-from .decompose_goal import DEFAULT_ACTION, MAX_STEPS, DecomposeGoalTool
+from .decompose_goal import (
+    AUTO_APPROVE_CLIENT_SECONDS,
+    DEFAULT_ACTION,
+    MAX_STEPS,
+    DecomposeGoalTool,
+    _no_user_action_since,
+)
 from .models import ErrorResponse, TaskDecompositionResponse
 
+# Captured before the autouse fixture stubs the real scheduler.
+_REAL_SCHEDULE_AUTO_APPROVE = decompose_goal_module._schedule_auto_approve
+
 _USER_ID = "test-user-decompose-goal"
 
 _VALID_STEPS = [
@@ -19,6 +34,18 @@
 ]
 
 
+@pytest.fixture(autouse=True)
+def _stub_auto_approve_scheduler():
+    """The existing happy-path tests don't have a database; stub the
+    fire-and-forget scheduler so they don't kick off real timers that try to
+    hit Redis/Postgres. Tests that exercise auto-approve override this with
+    their own patches inside the test body."""
+    with patch.object(
+        decompose_goal_module, "_schedule_auto_approve", lambda *a, **kw: None
+    ):
+        yield
+
+
 @pytest.fixture()
 def tool() -> DecomposeGoalTool:
     return DecomposeGoalTool()
@@ -253,3 +280,210 @@ async def test_step_ids_are_sequential(tool: DecomposeGoalTool, session):
     assert isinstance(result, TaskDecompositionResponse)
     for i, step in enumerate(result.steps):
         assert step.step_id == f"step_{i + 1}"
+
+
+# ---------------------------------------------------------------------------
+# auto_approve_seconds field
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_response_includes_auto_approve_seconds(tool: DecomposeGoalTool, session):
+    """The response carries the countdown so the frontend has a single
+    source of truth instead of a hard-coded constant."""
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=_VALID_STEPS,
+    )
+    assert isinstance(result, TaskDecompositionResponse)
+    assert result.auto_approve_seconds == AUTO_APPROVE_CLIENT_SECONDS
+
+
+# ---------------------------------------------------------------------------
+# Predicate: _no_user_action_since
+# ---------------------------------------------------------------------------
+
+
+def test_predicate_passes_when_no_user_messages_after_baseline():
+    session = make_session(_USER_ID)
+    session.messages.append(
+        ChatMessage(role="assistant", content="tool call", sequence=5)
+    )
+    assert _no_user_action_since(5)(session) is True
+
+
+def test_predicate_rejects_when_user_message_after_baseline():
+    session = make_session(_USER_ID)
+    session.messages.append(
+        ChatMessage(role="assistant", content="tool call", sequence=5)
+    )
+    session.messages.append(
+        ChatMessage(role="user", content="user replied", sequence=6)
+    )
+    assert _no_user_action_since(5)(session) is False
+
+
+def test_predicate_ignores_assistant_messages_after_baseline():
+    """Only user messages count as 'user action' — assistant messages are
+    just the LLM continuing on its own."""
+    session = make_session(_USER_ID)
+    session.messages.append(
+        ChatMessage(role="assistant", content="more stuff", sequence=6)
+    )
+    assert _no_user_action_since(5)(session) is True
+
+
+# ---------------------------------------------------------------------------
+# Server-side auto-approve task — full flow
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_auto_approve_fires_when_user_idle():
+    """When no user message is appended after the baseline sequence, the
+    task should append the synthetic approval and enqueue a new turn."""
+    session_id = "session-auto-approve-idle"
+
+    captured_message = {}
+
+    async def fake_append_message_if(session_id, message, predicate):
+        captured_message["msg"] = message
+        return make_session(_USER_ID)
+
+    fake_enqueue = AsyncMock()
+    fake_create_session = AsyncMock()
+
+    with (
+        patch(
+            "backend.copilot.tools.decompose_goal.append_message_if",
+            new=fake_append_message_if,
+        ),
+        patch(
+            "backend.copilot.tools.decompose_goal.AUTO_APPROVE_SERVER_SECONDS",
+            0,
+        ),
+        patch(
+            "backend.copilot.executor.utils.enqueue_copilot_turn",
+            new=fake_enqueue,
+        ),
+        patch(
+            "backend.copilot.stream_registry.create_session",
+            new=fake_create_session,
+        ),
+    ):
+        await decompose_goal_module._run_auto_approve(
+            session_id=session_id,
+            user_id=_USER_ID,
+            baseline_sequence=5,
+        )
+
+    assert captured_message["msg"].role == "user"
+    assert captured_message["msg"].content == "Approved. Please build the agent."
+    fake_create_session.assert_awaited_once()
+    fake_enqueue.assert_awaited_once()
+    assert fake_enqueue.await_args is not None
+    enqueue_kwargs = fake_enqueue.await_args.kwargs
+    assert enqueue_kwargs["session_id"] == session_id
+    assert enqueue_kwargs["message"] == "Approved. Please build the agent."
+    assert enqueue_kwargs["is_user_message"] is True
+
+
+@pytest.mark.asyncio
+async def test_auto_approve_skips_when_user_already_acted():
+    """If append_message_if returns None (predicate rejected because the
+    user already sent a message), no turn should be enqueued."""
+    fake_append_message_if = AsyncMock(return_value=None)
+    fake_enqueue = AsyncMock()
+    fake_create_session = AsyncMock()
+
+    with (
+        patch(
+            "backend.copilot.tools.decompose_goal.append_message_if",
+            new=fake_append_message_if,
+        ),
+        patch(
+            "backend.copilot.tools.decompose_goal.AUTO_APPROVE_SERVER_SECONDS",
+            0,
+        ),
+        patch(
+            "backend.copilot.executor.utils.enqueue_copilot_turn",
+            new=fake_enqueue,
+        ),
+        patch(
+            "backend.copilot.stream_registry.create_session",
+            new=fake_create_session,
+        ),
+    ):
+        await decompose_goal_module._run_auto_approve(
+            session_id="session-acted",
+            user_id=_USER_ID,
+            baseline_sequence=5,
+        )
+
+    fake_append_message_if.assert_awaited_once()
+    fake_enqueue.assert_not_awaited()
+    fake_create_session.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_auto_approve_swallows_unexpected_errors():
+    """A failure inside the task must never propagate — the worker should
+    keep running."""
+
+    async def boom(*args, **kwargs):
+        raise RuntimeError("kaboom")
+
+    with (
+        patch(
+            "backend.copilot.tools.decompose_goal.append_message_if",
+            new=boom,
+        ),
+        patch(
+            "backend.copilot.tools.decompose_goal.AUTO_APPROVE_SERVER_SECONDS",
+            0,
+        ),
+    ):
+        # Should not raise.
+        await decompose_goal_module._run_auto_approve(
+            session_id="session-error",
+            user_id=_USER_ID,
+            baseline_sequence=0,
+        )
+
+
+@pytest.mark.asyncio
+async def test_schedule_auto_approve_creates_task(monkeypatch):
+    """_schedule_auto_approve should add a task to the tracking set and
+    auto-remove it on completion."""
+    monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 0)
+    fake_run = AsyncMock()
+    monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
+
+    session = make_session(_USER_ID)
+    session.messages.append(
+        ChatMessage(role="assistant", content="tool call", sequence=3)
+    )
+
+    _REAL_SCHEDULE_AUTO_APPROVE(
+        session_id="session-schedule",
+        user_id=_USER_ID,
+        session=session,
+    )
+
+    # Wait for the scheduled task to complete.
+    await asyncio.sleep(0)
+    while decompose_goal_module._auto_approve_tasks:
+        await asyncio.sleep(0)
+
+    fake_run.assert_awaited_once_with("session-schedule", _USER_ID, 3)
+
+
+def test_schedule_auto_approve_no_op_without_session_id():
+    """Empty session id should be a no-op (defensive)."""
+    session = make_session(_USER_ID)
+    decompose_goal_module._schedule_auto_approve(
+        session_id=None, user_id=_USER_ID, session=session
+    )
+    assert len(decompose_goal_module._auto_approve_tasks) == 0
diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.py
index 63d63d3965c7..e9eb7ca4edee 100644
--- a/autogpt_platform/backend/backend/copilot/tools/models.py
+++ b/autogpt_platform/backend/backend/copilot/tools/models.py
@@ -729,6 +729,14 @@ class TaskDecompositionResponse(ToolResponseBase):
         default=0, description="Number of steps (auto-derived from steps list)"
     )
     requires_approval: bool = True
+    auto_approve_seconds: int = Field(
+        default=60,
+        description=(
+            "Seconds the client should count down before auto-approving. "
+            "Kept in sync with the server-side fallback timer, which runs a "
+            "grace period longer to absorb network latency."
+        ),
+    )
 
     @model_validator(mode="after")
     def sync_step_count(self) -> "TaskDecompositionResponse":
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 74082a8277da..f257a160239e 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -27,7 +27,9 @@ import {
   ToolIcon,
 } from "./helpers";
 
-const COUNTDOWN_SECONDS = 60;
+// Fallback used only if the backend response omits auto_approve_seconds
+// (older sessions). The authoritative value comes from the tool output.
+const FALLBACK_COUNTDOWN_SECONDS = 60;
 const RADIUS = 15;
 const CIRCUMFERENCE = 2 * Math.PI * RADIUS;
 
@@ -62,7 +64,13 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     isDecompositionOutput(output) &&
     output.requires_approval;
 
-  const [secondsLeft, setSecondsLeft] = useState(COUNTDOWN_SECONDS);
+  // Authoritative countdown comes from the backend tool response so the
+  // server-side fallback timer and the client are guaranteed to agree.
+  const countdownSeconds =
+    (output && isDecompositionOutput(output) && output.auto_approve_seconds) ||
+    FALLBACK_COUNTDOWN_SECONDS;
+
+  const [secondsLeft, setSecondsLeft] = useState(countdownSeconds);
   // timerActive becomes false when the user clicks Modify — stops countdown and auto-approve.
   const [timerActive, setTimerActive] = useState(true);
   const [isEditing, setIsEditing] = useState(false);
@@ -153,7 +161,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     }
   }, [secondsLeft, timerActive, showActions]); // approve reads refs only — safe to omit
 
-  const progress = secondsLeft / COUNTDOWN_SECONDS;
+  const progress = secondsLeft / countdownSeconds;
   const dashOffset = CIRCUMFERENCE * (1 - progress);
   const stepCount = isEditing
     ? editableSteps.length
@@ -263,10 +271,10 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                   </Button>
                 ) : (
                   <>
-                    {/* Timer button — same ghost style as Modify, ring wraps the number inline */}
-                    <Button variant="ghost" onClick={approve}>
-                      <span className="group/label inline-flex items-center gap-1">
-                        <span className="inline-flex items-center gap-1 group-hover/label:hidden">
+                    {/* Primary CTA — encourages user to run the agent */}
+                    <Button variant="primary" size="small" onClick={approve}>
+                      <span className="group/label inline-flex items-center gap-2">
+                        <span className="inline-flex items-center gap-1.5 group-hover/label:hidden">
                           Starting in
                           <span className="relative inline-flex h-6 w-6 items-center justify-center">
                             <svg
@@ -282,7 +290,7 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                                 fill="none"
                                 stroke="currentColor"
                                 strokeWidth="2"
-                                className="text-neutral-300"
+                                className="text-white/30"
                               />
                               <circle
                                 cx="17"
@@ -294,22 +302,20 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                                 strokeLinecap="round"
                                 strokeDasharray={CIRCUMFERENCE}
                                 strokeDashoffset={dashOffset}
-                                className="text-neutral-600 transition-[stroke-dashoffset] duration-1000 ease-linear"
+                                className="text-white transition-[stroke-dashoffset] duration-1000 ease-linear"
                               />
                             </svg>
-                            <span className="relative z-10 text-[11px] font-semibold tabular-nums text-foreground">
+                            <span className="relative z-10 text-[11px] font-semibold tabular-nums text-white">
                               {secondsLeft}
                             </span>
                           </span>
-                          s
                         </span>
                         <span className="hidden group-hover/label:inline">
                           Start now
                         </span>
                       </span>
                     </Button>
-                    <span className="text-neutral-300">|</span>
-                    <Button variant="ghost" onClick={handleModify}>
+                    <Button variant="ghost" size="small" onClick={handleModify}>
                       <span className="inline-flex items-center gap-1.5">
                         <PencilSimpleIcon size={14} weight="bold" />
                         Modify
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
index 4cfdec576bb2..43c3118c78a4 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -26,6 +26,7 @@ export interface TaskDecompositionOutput {
   steps: DecompositionStep[];
   step_count: number;
   requires_approval: boolean;
+  auto_approve_seconds?: number;
 }
 
 export interface DecomposeErrorOutput {
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index de5c6fc2ed9c..e89f8540d383 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -13788,6 +13788,12 @@
             "type": "boolean",
             "title": "Requires Approval",
             "default": true
+          },
+          "auto_approve_seconds": {
+            "type": "integer",
+            "title": "Auto Approve Seconds",
+            "description": "Seconds the client should count down before auto-approving. Kept in sync with the server-side fallback timer, which runs a grace period longer to absorb network latency.",
+            "default": 60
           }
         },
         "type": "object",

From f7601d06ed50c832bfecf393afe008f7f01cc94d Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 10 Apr 2026 17:44:50 +0200
Subject: [PATCH 15/61] fix(copilot): resume decompose_goal countdown from
 server timestamp

Reopening a session was restarting the client countdown from a fresh 60s,
even though the server had been counting the whole time. Now the timer
reflects real elapsed time so the user sees the actual remaining seconds
(or 0, which auto-approves immediately).

- backend: stamp UTC created_at on TaskDecompositionResponse via a default
  factory. The timestamp is set when the tool returns and persisted in the
  message content JSON, so it survives DB round-trips.
- frontend: lazy-init secondsLeft from (auto_approve_seconds -
  (Date.now() - created_at)), clamped to [0, total]. Older messages
  without created_at fall back to a fresh full countdown (existing
  behaviour).
- Test: assert created_at is stamped within the duration of _execute().

Note: openapi.json regen is skipped in this commit because the existing
REST server is in use; the frontend reads tool output as opaque JSON via
custom helpers, so the regen is not required for the feature to work.
Regen later for completeness.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/tools/decompose_goal_test.py      | 20 ++++++++++++
 .../backend/backend/copilot/tools/models.py   | 11 ++++++-
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 31 ++++++++++++++++++-
 .../copilot/tools/DecomposeGoal/helpers.tsx   |  4 +++
 4 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index 50984bc58ff8..e72b10ceb61e 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -1,6 +1,7 @@
 """Unit tests for DecomposeGoalTool."""
 
 import asyncio
+from datetime import UTC, datetime
 from unittest.mock import AsyncMock, patch
 
 import pytest
@@ -301,6 +302,25 @@ async def test_response_includes_auto_approve_seconds(tool: DecomposeGoalTool, s
     assert result.auto_approve_seconds == AUTO_APPROVE_CLIENT_SECONDS
 
 
+@pytest.mark.asyncio
+async def test_response_includes_created_at(tool: DecomposeGoalTool, session):
+    """created_at must be stamped at execution time so the client can
+    compute remaining countdown when the user reopens the session."""
+    before = datetime.now(UTC)
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build agent",
+        steps=_VALID_STEPS,
+    )
+    after = datetime.now(UTC)
+
+    assert isinstance(result, TaskDecompositionResponse)
+    assert isinstance(result.created_at, datetime)
+    # Stamped during the call.
+    assert before <= result.created_at <= after
+
+
 # ---------------------------------------------------------------------------
 # Predicate: _no_user_action_since
 # ---------------------------------------------------------------------------
diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.py
index e9eb7ca4edee..dcad0819adc0 100644
--- a/autogpt_platform/backend/backend/copilot/tools/models.py
+++ b/autogpt_platform/backend/backend/copilot/tools/models.py
@@ -1,6 +1,6 @@
 """Pydantic models for tool responses."""
 
-from datetime import datetime
+from datetime import UTC, datetime
 from enum import Enum
 from typing import Any, Literal
 
@@ -737,6 +737,15 @@ class TaskDecompositionResponse(ToolResponseBase):
             "grace period longer to absorb network latency."
         ),
     )
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(UTC),
+        description=(
+            "UTC timestamp when the tool returned. The client uses this with "
+            "auto_approve_seconds to compute the correct remaining countdown "
+            "when the user reopens the session — so the timer reflects real "
+            "elapsed time instead of restarting from zero."
+        ),
+    )
 
     @model_validator(mode="after")
     def sync_step_count(self) -> "TaskDecompositionResponse":
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index f257a160239e..53992d9e1326 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -25,6 +25,7 @@ import {
   isDecompositionOutput,
   isErrorOutput,
   ToolIcon,
+  type DecomposeGoalOutput,
 } from "./helpers";
 
 // Fallback used only if the backend response omits auto_approve_seconds
@@ -33,6 +34,29 @@ const FALLBACK_COUNTDOWN_SECONDS = 60;
 const RADIUS = 15;
 const CIRCUMFERENCE = 2 * Math.PI * RADIUS;
 
+/**
+ * Compute remaining countdown seconds, deriving elapsed time from the
+ * backend-stamped ``created_at`` so the timer reflects real elapsed time
+ * when the user reopens the session — instead of restarting from full.
+ *
+ * Falls back to the full countdown when ``created_at`` is missing (older
+ * sessions stored before this field existed) or unparseable. Clamps to
+ * ``[0, total]`` to defend against client clock skew producing future
+ * timestamps.
+ */
+function computeRemainingSeconds(
+  output: DecomposeGoalOutput | null,
+  fallback: number,
+): number {
+  if (!output || !isDecompositionOutput(output)) return fallback;
+  const total = output.auto_approve_seconds ?? fallback;
+  if (!output.created_at) return total;
+  const createdAtMs = new Date(output.created_at).getTime();
+  if (Number.isNaN(createdAtMs)) return total;
+  const elapsedSec = (Date.now() - createdAtMs) / 1000;
+  return Math.max(0, Math.min(total, Math.round(total - elapsedSec)));
+}
+
 interface EditableStep {
   step_id: string;
   description: string;
@@ -70,7 +94,12 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     (output && isDecompositionOutput(output) && output.auto_approve_seconds) ||
     FALLBACK_COUNTDOWN_SECONDS;
 
-  const [secondsLeft, setSecondsLeft] = useState(countdownSeconds);
+  // Lazy initializer: runs once on mount and seeds remaining time from the
+  // backend ``created_at`` so reopening a session resumes the countdown
+  // instead of restarting it.
+  const [secondsLeft, setSecondsLeft] = useState(() =>
+    computeRemainingSeconds(output, FALLBACK_COUNTDOWN_SECONDS),
+  );
   // timerActive becomes false when the user clicks Modify — stops countdown and auto-approve.
   const [timerActive, setTimerActive] = useState(true);
   const [isEditing, setIsEditing] = useState(false);
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
index 43c3118c78a4..8df68fe755aa 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -27,6 +27,10 @@ export interface TaskDecompositionOutput {
   step_count: number;
   requires_approval: boolean;
   auto_approve_seconds?: number;
+  // ISO 8601 UTC timestamp stamped by the backend when the tool returned.
+  // Used to compute the actual remaining countdown when the user reopens
+  // the session, so the timer doesn't restart from full each time.
+  created_at?: string;
 }
 
 export interface DecomposeErrorOutput {

From f467ead8552f258ece1765c96356e9052977b071 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 10 Apr 2026 18:49:17 +0200
Subject: [PATCH 16/61] fix(copilot): disable decompose_goal Approve/Modify
 while message is streaming
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

After the build plan box appears, the assistant continues streaming a
short summary text. Clicking Approve or Modify in that 1-2s window failed
because the chat session is locked to the in-flight turn — sending a new
user message gets rejected.

- ChatMessagesContainer now forwards isCurrentlyStreaming through
  renderSegments → MessagePartRenderer → DecomposeGoalTool.
- DecomposeGoalTool computes actionsEnabled = showActions && !streaming
  and uses it to (a) disable the Approve, Modify, and timer buttons and
  (b) gate the auto-approve effect so the timer can hit 0 mid-stream
  without firing — the effect re-runs and approves once streaming ends.
- The countdown ring keeps ticking during streaming so it stays in sync
  with the server-side timer.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../ChatMessagesContainer.tsx                 |  4 ++
 .../components/MessagePartRenderer.tsx        |  3 ++
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 46 +++++++++++++++----
 3 files changed, 45 insertions(+), 8 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
index 620c108388aa..f2c0d9e4427c 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
@@ -51,6 +51,7 @@ function renderSegments(
   messageID: string,
   onRetry?: () => void,
   isLastMessage?: boolean,
+  isMessageStreaming?: boolean,
 ): React.ReactNode[] {
   return segments.map((seg, segIdx) => {
     if (seg.kind === "collapsed-group") {
@@ -64,6 +65,7 @@ function renderSegments(
         partIndex={seg.index}
         onRetry={onRetry}
         isLastMessage={isLastMessage}
+        isMessageStreaming={isMessageStreaming}
       />
     );
   });
@@ -375,6 +377,7 @@ export function ChatMessagesContainer({
                       message.id,
                       isLastAssistant ? onRetry : undefined,
                       isLastAssistant,
+                      isCurrentlyStreaming,
                     )
                   : message.parts.map((part, i) => (
                       <MessagePartRenderer
@@ -384,6 +387,7 @@ export function ChatMessagesContainer({
                         partIndex={i}
                         onRetry={isLastAssistant ? onRetry : undefined}
                         isLastMessage={isLastAssistant}
+                        isMessageStreaming={isCurrentlyStreaming}
                       />
                     ))}
                 {isLastInTurn && !isCurrentlyStreaming && (
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
index b86f73d86bc7..a4dbfb04bec9 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
@@ -95,6 +95,7 @@ interface Props {
   partIndex: number;
   onRetry?: () => void;
   isLastMessage?: boolean;
+  isMessageStreaming?: boolean;
 }
 
 export function MessagePartRenderer({
@@ -103,6 +104,7 @@ export function MessagePartRenderer({
   partIndex,
   onRetry,
   isLastMessage,
+  isMessageStreaming,
 }: Props) {
   const key = `${messageID}-${partIndex}`;
 
@@ -176,6 +178,7 @@ export function MessagePartRenderer({
           key={key}
           part={part as ToolUIPart}
           isLastMessage={isLastMessage}
+          isMessageStreaming={isMessageStreaming}
         />
       );
     case "tool-create_agent":
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 53992d9e1326..33b7e5939c59 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -68,9 +68,17 @@ interface EditableStep {
 interface Props {
   part: ToolUIPart;
   isLastMessage?: boolean;
+  // True while the parent assistant message is still streaming. We disable
+  // Approve/Modify in this window because the chat session is locked to
+  // the in-flight turn — sending a new user message would fail.
+  isMessageStreaming?: boolean;
 }
 
-export function DecomposeGoalTool({ part, isLastMessage }: Props) {
+export function DecomposeGoalTool({
+  part,
+  isLastMessage,
+  isMessageStreaming,
+}: Props) {
   const text = getAnimationText(part);
   const { onSend } = useCopilotChatActions();
 
@@ -88,6 +96,12 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     isDecompositionOutput(output) &&
     output.requires_approval;
 
+  // The Approve/Modify buttons are visible (so the user knows what's
+  // coming) but click-disabled while the assistant is still streaming
+  // its summary text after the tool call. The countdown ring keeps
+  // ticking so it stays in sync with the server-side timer.
+  const actionsEnabled = showActions && !isMessageStreaming;
+
   // Authoritative countdown comes from the backend tool response so the
   // server-side fallback timer and the client are guaranteed to agree.
   const countdownSeconds =
@@ -181,14 +195,16 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
     return () => clearInterval(interval);
   }, [showActions, timerActive, part.toolCallId]);
 
-  // Auto-approve when countdown reaches 0 (only if timer is still active and actions visible).
-  // showActions prevents firing after isLastMessage changes (race condition guard).
+  // Auto-approve when countdown reaches 0 — but only after the assistant
+  // has finished streaming its summary text. Firing during streaming would
+  // hit the same locked-session failure as a manual click. If the timer
+  // hits 0 mid-stream, this effect re-runs when actionsEnabled flips true.
   // approve() is stable via approvedRef — safe to omit from deps.
   useEffect(() => {
-    if (secondsLeft === 0 && timerActive && showActions) {
+    if (secondsLeft === 0 && timerActive && actionsEnabled) {
       approve();
     }
-  }, [secondsLeft, timerActive, showActions]); // approve reads refs only — safe to omit
+  }, [secondsLeft, timerActive, actionsEnabled]); // approve reads refs only — safe to omit
 
   const progress = secondsLeft / countdownSeconds;
   const dashOffset = CIRCUMFERENCE * (1 - progress);
@@ -292,7 +308,11 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
             {showActions && (
               <div className="flex items-center gap-2 pt-1">
                 {isEditing ? (
-                  <Button variant="primary" onClick={approve}>
+                  <Button
+                    variant="primary"
+                    onClick={approve}
+                    disabled={!actionsEnabled}
+                  >
                     <span className="inline-flex items-center gap-1.5">
                       <CheckIcon size={14} weight="bold" />
                       Approve
@@ -301,7 +321,12 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                 ) : (
                   <>
                     {/* Primary CTA — encourages user to run the agent */}
-                    <Button variant="primary" size="small" onClick={approve}>
+                    <Button
+                      variant="primary"
+                      size="small"
+                      onClick={approve}
+                      disabled={!actionsEnabled}
+                    >
                       <span className="group/label inline-flex items-center gap-2">
                         <span className="inline-flex items-center gap-1.5 group-hover/label:hidden">
                           Starting in
@@ -344,7 +369,12 @@ export function DecomposeGoalTool({ part, isLastMessage }: Props) {
                         </span>
                       </span>
                     </Button>
-                    <Button variant="ghost" size="small" onClick={handleModify}>
+                    <Button
+                      variant="ghost"
+                      size="small"
+                      onClick={handleModify}
+                      disabled={!actionsEnabled}
+                    >
                       <span className="inline-flex items-center gap-1.5">
                         <PencilSimpleIcon size={14} weight="bold" />
                         Modify

From ed989801d2f85beedcf3b2868855431092e601c9 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 10 Apr 2026 20:54:18 +0200
Subject: [PATCH 17/61] fix(copilot): index-based predicate so manual approve
 cancels server timer
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The auto-approve task was firing a duplicate "Approved" message after the
agent had already been built manually. The predicate compared
ChatMessage.sequence against a baseline, but _save_session_to_db assigns
sequences in the DB without writing them back to the in-memory message
objects, and cache_chat_session writes those (sequence=None) objects to
Redis. So the predicate's loaded-from-cache view had None sequences for
freshly-appended messages, treated them as 0, and missed the user's
"Approved" entirely — leaving the timer to fire after the build had
already completed and re-injecting "Approved" for a duplicate turn.

Fix: capture len(session.messages) at schedule time and check for any
user-role message at index >= baseline. Indices are monotonic and require
no DB-side sequence bookkeeping.

Adds a regression test that constructs a session with sequence=None on
the user message, asserting the predicate detects it.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py   | 43 ++++++++----
 .../copilot/tools/decompose_goal_test.py      | 68 ++++++++++++-------
 2 files changed, 73 insertions(+), 38 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 8c143c928d42..afc86759d92e 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -38,13 +38,25 @@
 _auto_approve_tasks: set[asyncio.Task] = set()
 
 
-def _no_user_action_since(baseline_sequence: int):
-    """Predicate: returns True iff no user message has been appended after
-    the message at ``baseline_sequence``."""
+def _no_user_action_since(baseline_index: int):
+    """Predicate: returns True iff no ``role == "user"`` message exists at
+    or after ``baseline_index`` in the session message list.
+
+    Why an index instead of ``ChatMessage.sequence``: ``_save_session_to_db``
+    persists messages with auto-assigned sequences in the DB but does NOT
+    write those sequences back onto the in-memory ``ChatMessage`` objects,
+    and ``cache_chat_session`` writes the in-memory copy to Redis. So when
+    this predicate later loads the session from cache, freshly-appended
+    messages have ``sequence=None``, which would falsely register as 0 and
+    miss them entirely — the predicate would treat the user's manual
+    "Approved" as if it never happened, and the auto-approve would fire a
+    duplicate after the agent build had already completed. Indices are
+    monotonic and require no DB-side bookkeeping.
+    """
 
     def _check(session: ChatSession) -> bool:
-        for m in session.messages:
-            if m.role == "user" and (m.sequence or 0) > baseline_sequence:
+        for m in session.messages[baseline_index:]:
+            if m.role == "user":
                 return False
         return True
 
@@ -54,7 +66,7 @@ def _check(session: ChatSession) -> bool:
 async def _run_auto_approve(
     session_id: str,
     user_id: str | None,
-    baseline_sequence: int,
+    baseline_index: int,
 ) -> None:
     """Wait the server-side timeout and inject a synthetic approval if the
     user has not acted in the meantime.
@@ -75,7 +87,7 @@ async def _run_auto_approve(
         result = await append_message_if(
             session_id=session_id,
             message=approval,
-            predicate=_no_user_action_since(baseline_sequence),
+            predicate=_no_user_action_since(baseline_index),
         )
         if result is None:
             # User already acted (or the session is gone) — nothing to do.
@@ -114,16 +126,17 @@ async def _run_auto_approve(
 def _schedule_auto_approve(
     session_id: str | None, user_id: str | None, session: ChatSession
 ) -> None:
-    """Schedule the fire-and-forget auto-approve task for this session."""
+    """Schedule the fire-and-forget auto-approve task for this session.
+
+    The baseline is the current message-list length: any message that
+    arrives at or after this index is "after the decomposition", so a
+    user message there means the user (or a follow-up turn) has acted
+    and the auto-approve should be skipped.
+    """
     if not session_id:
         return
-    baseline_sequence = max(
-        (m.sequence or 0 for m in session.messages),
-        default=0,
-    )
-    task = asyncio.create_task(
-        _run_auto_approve(session_id, user_id, baseline_sequence)
-    )
+    baseline_index = len(session.messages)
+    task = asyncio.create_task(_run_auto_approve(session_id, user_id, baseline_index))
     _auto_approve_tasks.add(task)
     task.add_done_callback(_auto_approve_tasks.discard)
 
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index e72b10ceb61e..62a8981bd353 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -328,31 +328,51 @@ async def test_response_includes_created_at(tool: DecomposeGoalTool, session):
 
 def test_predicate_passes_when_no_user_messages_after_baseline():
     session = make_session(_USER_ID)
-    session.messages.append(
-        ChatMessage(role="assistant", content="tool call", sequence=5)
-    )
-    assert _no_user_action_since(5)(session) is True
+    # Two pre-existing messages (indices 0, 1).
+    session.messages.append(ChatMessage(role="user", content="initial"))
+    session.messages.append(ChatMessage(role="assistant", content="tool call"))
+    # Tool result lands at index 2 — this is what the executor appends after
+    # _execute returns. baseline_index was captured at 2 inside _execute.
+    session.messages.append(ChatMessage(role="tool", content="{...}"))
+    assert _no_user_action_since(2)(session) is True
 
 
 def test_predicate_rejects_when_user_message_after_baseline():
     session = make_session(_USER_ID)
-    session.messages.append(
-        ChatMessage(role="assistant", content="tool call", sequence=5)
-    )
-    session.messages.append(
-        ChatMessage(role="user", content="user replied", sequence=6)
-    )
-    assert _no_user_action_since(5)(session) is False
+    session.messages.append(ChatMessage(role="user", content="initial"))
+    session.messages.append(ChatMessage(role="assistant", content="tool call"))
+    session.messages.append(ChatMessage(role="tool", content="{...}"))
+    session.messages.append(ChatMessage(role="user", content="Approved"))
+    assert _no_user_action_since(2)(session) is False
 
 
 def test_predicate_ignores_assistant_messages_after_baseline():
     """Only user messages count as 'user action' — assistant messages are
     just the LLM continuing on its own."""
     session = make_session(_USER_ID)
-    session.messages.append(
-        ChatMessage(role="assistant", content="more stuff", sequence=6)
-    )
-    assert _no_user_action_since(5)(session) is True
+    session.messages.append(ChatMessage(role="user", content="initial"))
+    session.messages.append(ChatMessage(role="assistant", content="tool call"))
+    session.messages.append(ChatMessage(role="tool", content="{...}"))
+    session.messages.append(ChatMessage(role="assistant", content="summary"))
+    assert _no_user_action_since(2)(session) is True
+
+
+def test_predicate_handles_messages_with_none_sequence():
+    """Regression: the previous sequence-based predicate ignored messages
+    whose sequence was None (which is what cached/in-memory messages have
+    until they're round-tripped through the DB), causing the auto-approve
+    to fire after the user had already manually approved. The new
+    index-based predicate must catch user messages regardless of sequence.
+    """
+    session = make_session(_USER_ID)
+    session.messages.append(ChatMessage(role="user", content="initial"))
+    session.messages.append(ChatMessage(role="assistant", content="tool call"))
+    session.messages.append(ChatMessage(role="tool", content="{...}"))
+    # Sequence intentionally None — the cache often returns this state.
+    user_msg = ChatMessage(role="user", content="Approved", sequence=None)
+    session.messages.append(user_msg)
+    assert user_msg.sequence is None
+    assert _no_user_action_since(2)(session) is False
 
 
 # ---------------------------------------------------------------------------
@@ -396,7 +416,7 @@ async def fake_append_message_if(session_id, message, predicate):
         await decompose_goal_module._run_auto_approve(
             session_id=session_id,
             user_id=_USER_ID,
-            baseline_sequence=5,
+            baseline_index=5,
         )
 
     assert captured_message["msg"].role == "user"
@@ -439,7 +459,7 @@ async def test_auto_approve_skips_when_user_already_acted():
         await decompose_goal_module._run_auto_approve(
             session_id="session-acted",
             user_id=_USER_ID,
-            baseline_sequence=5,
+            baseline_index=5,
         )
 
     fake_append_message_if.assert_awaited_once()
@@ -469,22 +489,24 @@ async def boom(*args, **kwargs):
         await decompose_goal_module._run_auto_approve(
             session_id="session-error",
             user_id=_USER_ID,
-            baseline_sequence=0,
+            baseline_index=0,
         )
 
 
 @pytest.mark.asyncio
 async def test_schedule_auto_approve_creates_task(monkeypatch):
     """_schedule_auto_approve should add a task to the tracking set and
-    auto-remove it on completion."""
+    auto-remove it on completion. The baseline passed to _run_auto_approve
+    must be the current message-list length at schedule time."""
     monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 0)
     fake_run = AsyncMock()
     monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
 
     session = make_session(_USER_ID)
-    session.messages.append(
-        ChatMessage(role="assistant", content="tool call", sequence=3)
-    )
+    # Two messages already in the session — the next one (the tool result)
+    # will land at index 2.
+    session.messages.append(ChatMessage(role="user", content="initial"))
+    session.messages.append(ChatMessage(role="assistant", content="tool call"))
 
     _REAL_SCHEDULE_AUTO_APPROVE(
         session_id="session-schedule",
@@ -497,7 +519,7 @@ async def test_schedule_auto_approve_creates_task(monkeypatch):
     while decompose_goal_module._auto_approve_tasks:
         await asyncio.sleep(0)
 
-    fake_run.assert_awaited_once_with("session-schedule", _USER_ID, 3)
+    fake_run.assert_awaited_once_with("session-schedule", _USER_ID, 2)
 
 
 def test_schedule_auto_approve_no_op_without_session_id():

From fdfd53b45ebfb2d053b8fadd3004915b58cd2004 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 10 Apr 2026 21:42:28 +0200
Subject: [PATCH 18/61] fix(copilot): don't auto-approve decomposition on mount
 when deadline already passed
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If the user reopened the tab between 60s and 90s after a decomposition
was created, the lazy initializer for ``secondsLeft`` would return 0
(server-stamped deadline already elapsed). The auto-approve useEffect
fires whenever ``secondsLeft === 0``, so it would silently send the
"Approved" message on mount with no user interaction — even if the user
came back specifically to click Modify.

Track in a ref whether the lazy init returned 0 because the deadline
had already passed (vs. 0 because the timer counted down from a
positive value), and skip the auto-approve in that case. The server's
own fallback timer (running 30s longer than the client) handles the
"user never returns" path, so the client doesn't need to silently fire
on mount. The user can still click Approve or Modify manually; the
server will inject its own approval at 90s if neither happens.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 33 ++++++++++++++++---
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 33b7e5939c59..a4a6b509b8b6 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -119,6 +119,20 @@ export function DecomposeGoalTool({
   const [isEditing, setIsEditing] = useState(false);
   const [editableSteps, setEditableSteps] = useState<EditableStep[]>([]);
 
+  // True iff the lazy initializer above already returned 0 because the
+  // server-stamped deadline had elapsed before the user reopened the tab.
+  // The auto-approve effect uses this to avoid silently approving on mount
+  // — the server's own fallback timer will handle it within ~30s, and
+  // skipping the silent fire gives the user a chance to click Modify
+  // instead. Without this guard, reopening between 60-90s after creation
+  // would auto-approve with no interaction.
+  const wasInitiallyPastDeadlineRef = useRef(
+    secondsLeft === 0 &&
+      !!output &&
+      isDecompositionOutput(output) &&
+      !!output.created_at,
+  );
+
   const approvedRef = useRef(false);
   const onSendRef = useRef(onSend);
   const isEditingRef = useRef(isEditing);
@@ -196,12 +210,21 @@ export function DecomposeGoalTool({
   }, [showActions, timerActive, part.toolCallId]);
 
   // Auto-approve when countdown reaches 0 — but only after the assistant
-  // has finished streaming its summary text. Firing during streaming would
-  // hit the same locked-session failure as a manual click. If the timer
-  // hits 0 mid-stream, this effect re-runs when actionsEnabled flips true.
-  // approve() is stable via approvedRef — safe to omit from deps.
+  // has finished streaming its summary text, AND only if the timer
+  // actually counted down (not if it started at 0 because the deadline
+  // had already passed when the user reopened the tab). Firing on mount
+  // in the past-deadline case would silently approve without giving the
+  // user a chance to click Modify; the server's fallback timer covers
+  // that scenario instead. If the timer hits 0 mid-stream, this effect
+  // re-runs when actionsEnabled flips true. approve() is stable via
+  // approvedRef — safe to omit from deps.
   useEffect(() => {
-    if (secondsLeft === 0 && timerActive && actionsEnabled) {
+    if (
+      secondsLeft === 0 &&
+      timerActive &&
+      actionsEnabled &&
+      !wasInitiallyPastDeadlineRef.current
+    ) {
       approve();
     }
   }, [secondsLeft, timerActive, actionsEnabled]); // approve reads refs only — safe to omit

From 98470c27e19450b35cf7724c17a3288ad7d53c2d Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 10 Apr 2026 21:47:16 +0200
Subject: [PATCH 19/61] chore(backend): black-format platform_cost_test.py
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Pre-existing formatting issue inherited from the dev merge — black wants
one blank line between TestUsdToMicrodollars and TestMaskEmail, not two.
This is unrelated to the decomposition feature but blocks CI lint.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 autogpt_platform/backend/backend/data/platform_cost_test.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/autogpt_platform/backend/backend/data/platform_cost_test.py b/autogpt_platform/backend/backend/data/platform_cost_test.py
index dacd2c42ea98..4a2372628b64 100644
--- a/autogpt_platform/backend/backend/data/platform_cost_test.py
+++ b/autogpt_platform/backend/backend/data/platform_cost_test.py
@@ -35,7 +35,6 @@ def test_large_value(self):
         assert usd_to_microdollars(1.0) == 1_000_000
 
 
-
 class TestMaskEmail:
     def test_typical_email(self):
         assert _mask_email("user@example.com") == "us***@example.com"

From ca7dc221df24a7f2f447e49c9ef7806a2804a138 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 10 Apr 2026 21:57:33 +0200
Subject: [PATCH 20/61] chore(frontend): regenerate openapi.json with
 TaskDecompositionResponse.created_at

The created_at field was added to TaskDecompositionResponse a few commits
back but openapi.json was never regenerated, so the check-api-types CI
job (which re-exports the schema and asserts no diff) was failing.
Re-exporting via poetry run export-api-schema and prettier.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 autogpt_platform/frontend/src/app/api/openapi.json | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 6ef71a727a2b..13ac3a86bf57 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -14097,6 +14097,12 @@
             "title": "Auto Approve Seconds",
             "description": "Seconds the client should count down before auto-approving. Kept in sync with the server-side fallback timer, which runs a grace period longer to absorb network latency.",
             "default": 60
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time",
+            "title": "Created At",
+            "description": "UTC timestamp when the tool returned. The client uses this with auto_approve_seconds to compute the correct remaining countdown when the user reopens the session — so the timer reflects real elapsed time instead of restarting from zero."
           }
         },
         "type": "object",

From 8f5b9fa7911b8735e107c550d8b2f964d643d6c7 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Mon, 13 Apr 2026 19:47:53 +0200
Subject: [PATCH 21/61] fix(copilot): align server auto-approve timer with
 client at 60s
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the 30s grace period — both client and server now fire at 60s.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/backend/copilot/tools/decompose_goal.py       | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index afc86759d92e..4ff1455eba5e 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -24,13 +24,9 @@
 
 # Auto-approve countdown — single source of truth for both client and server.
 # The frontend reads ``auto_approve_seconds`` from the tool response and runs
-# the visible countdown. The server fallback runs slightly longer to absorb
-# network latency / SSE round-trip when the client also sends "Approved".
+# the visible countdown. The server fires at the same deadline.
 AUTO_APPROVE_CLIENT_SECONDS = 60
-AUTO_APPROVE_SERVER_GRACE_SECONDS = 30
-AUTO_APPROVE_SERVER_SECONDS = (
-    AUTO_APPROVE_CLIENT_SECONDS + AUTO_APPROVE_SERVER_GRACE_SECONDS
-)
+AUTO_APPROVE_SERVER_SECONDS = AUTO_APPROVE_CLIENT_SECONDS
 AUTO_APPROVE_MESSAGE = "Approved. Please build the agent."
 
 # Fire-and-forget tasks held to keep them alive and self-clean on completion.

From 7b60e4560492bcae5c8641630a1ba2c9abb20f90 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 14 Apr 2026 20:05:28 +0200
Subject: [PATCH 22/61] feat(copilot): cancel server auto-approve when user
 clicks Modify + use generated types
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Blocker fix: the server-side auto-approve timer fired even when the user
was editing steps via Modify, potentially building an agent against a plan
the user had explicitly chosen to change.

- backend: change _auto_approve_tasks set → _pending_auto_approvals dict
  keyed by session_id. Add cancel_auto_approve(session_id) that looks up
  and cancels the pending asyncio task.
- backend: new POST /sessions/{id}/cancel-auto-approve endpoint in
  chat/routes.py, following the existing cancel_session_task pattern.
- frontend: handleModify() now fires postV2CancelAutoApproveTask
  (generated hook) as a best-effort cancel before entering edit mode.
- helpers.tsx: import DecompositionStepModel from generated API types
  instead of hand-rolling the interface. TaskDecompositionOutput stays
  hand-rolled (runtime shape differs from generated type for created_at).
- Add session_id to TaskDecompositionOutput so the cancel call has it.
- Default step.status to "pending" where the generated type is optional.
- 2 new tests: cancel_auto_approve cancels pending task + returns false
  for unknown session.
- Regenerate openapi.json with the new endpoint.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/api/features/chat/routes.py       | 25 ++++++++++++
 .../backend/copilot/tools/decompose_goal.py   | 36 ++++++++++++-----
 .../copilot/tools/decompose_goal_test.py      | 35 +++++++++++++++-
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 16 +++++++-
 .../copilot/tools/DecomposeGoal/helpers.tsx   | 19 +++++----
 .../frontend/src/app/api/openapi.json         | 40 +++++++++++++++++++
 6 files changed, 147 insertions(+), 24 deletions(-)

diff --git a/autogpt_platform/backend/backend/api/features/chat/routes.py b/autogpt_platform/backend/backend/api/features/chat/routes.py
index 6288c6bda854..bfc9d45bfed6 100644
--- a/autogpt_platform/backend/backend/api/features/chat/routes.py
+++ b/autogpt_platform/backend/backend/api/features/chat/routes.py
@@ -717,6 +717,31 @@ async def cancel_session_task(
     return CancelSessionResponse(cancelled=True)
 
 
+@router.post(
+    "/sessions/{session_id}/cancel-auto-approve",
+    status_code=200,
+)
+async def cancel_auto_approve_task(
+    session_id: str,
+    user_id: Annotated[str, Security(auth.get_user_id)],
+) -> CancelSessionResponse:
+    """Cancel the pending auto-approve timer for a decompose_goal plan.
+
+    Called by the frontend when the user clicks "Modify" on the build-plan
+    box. Without this, the server-side timer would fire the default
+    "Approved" message while the user is still editing.
+    """
+    await _validate_and_get_session(session_id, user_id)
+
+    from backend.copilot.tools.decompose_goal import cancel_auto_approve
+
+    cancelled = cancel_auto_approve(session_id)
+    return CancelSessionResponse(
+        cancelled=cancelled,
+        reason=None if cancelled else "no_pending_auto_approve",
+    )
+
+
 @router.post(
     "/sessions/{session_id}/stream",
 )
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 4ff1455eba5e..2ac82fc9b8d6 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -29,9 +29,10 @@
 AUTO_APPROVE_SERVER_SECONDS = AUTO_APPROVE_CLIENT_SECONDS
 AUTO_APPROVE_MESSAGE = "Approved. Please build the agent."
 
-# Fire-and-forget tasks held to keep them alive and self-clean on completion.
-# Same pattern as ``backend/copilot/tools/agent_browser.py``.
-_auto_approve_tasks: set[asyncio.Task] = set()
+# Pending auto-approve tasks keyed by session_id. The dict allows
+# cancel_auto_approve() to look up and cancel the task for a specific
+# session when the user clicks "Modify" in the frontend.
+_pending_auto_approvals: dict[str, asyncio.Task] = {}
 
 
 def _no_user_action_since(baseline_index: int):
@@ -67,14 +68,11 @@ async def _run_auto_approve(
     """Wait the server-side timeout and inject a synthetic approval if the
     user has not acted in the meantime.
 
+    Cancelled when the user clicks "Modify" (via ``cancel_auto_approve``).
+
     Limitation: this lives in the executor process; if the worker restarts
     during the wait, the pending approval is lost (the user falls back to
     manual approve). Restart-resilience would need a Redis-backed scheduler.
-
-    Modify-mode caveat: clicking "Modify" stops the *client* timer, not this
-    one. Users have ``AUTO_APPROVE_SERVER_SECONDS`` total to finish editing
-    and click Approve, otherwise the server fires the default approval. A
-    follow-up should add an explicit cancel endpoint.
     """
     try:
         await asyncio.sleep(AUTO_APPROVE_SERVER_SECONDS)
@@ -119,6 +117,21 @@ async def _run_auto_approve(
         )
 
 
+def cancel_auto_approve(session_id: str) -> bool:
+    """Cancel the pending auto-approve task for a session.
+
+    Called by the ``/sessions/{session_id}/cancel-auto-approve`` endpoint
+    when the user clicks "Modify" in the build-plan UI. Returns True if a
+    pending task was found and cancelled, False otherwise.
+    """
+    task = _pending_auto_approvals.pop(session_id, None)
+    if task is not None and not task.done():
+        task.cancel()
+        logger.info("decompose_goal auto-approve cancelled for session %s", session_id)
+        return True
+    return False
+
+
 def _schedule_auto_approve(
     session_id: str | None, user_id: str | None, session: ChatSession
 ) -> None:
@@ -131,10 +144,13 @@ def _schedule_auto_approve(
     """
     if not session_id:
         return
+    # Cancel any existing pending approval for this session (e.g. if the
+    # LLM called decompose_goal twice in one turn).
+    cancel_auto_approve(session_id)
     baseline_index = len(session.messages)
     task = asyncio.create_task(_run_auto_approve(session_id, user_id, baseline_index))
-    _auto_approve_tasks.add(task)
-    task.add_done_callback(_auto_approve_tasks.discard)
+    _pending_auto_approvals[session_id] = task
+    task.add_done_callback(lambda t: _pending_auto_approvals.pop(session_id, None))
 
 
 class DecomposeGoalTool(BaseTool):
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index 62a8981bd353..1498f7810488 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -16,6 +16,7 @@
     MAX_STEPS,
     DecomposeGoalTool,
     _no_user_action_since,
+    cancel_auto_approve,
 )
 from .models import ErrorResponse, TaskDecompositionResponse
 
@@ -516,7 +517,7 @@ async def test_schedule_auto_approve_creates_task(monkeypatch):
 
     # Wait for the scheduled task to complete.
     await asyncio.sleep(0)
-    while decompose_goal_module._auto_approve_tasks:
+    while decompose_goal_module._pending_auto_approvals:
         await asyncio.sleep(0)
 
     fake_run.assert_awaited_once_with("session-schedule", _USER_ID, 2)
@@ -528,4 +529,34 @@ def test_schedule_auto_approve_no_op_without_session_id():
     decompose_goal_module._schedule_auto_approve(
         session_id=None, user_id=_USER_ID, session=session
     )
-    assert len(decompose_goal_module._auto_approve_tasks) == 0
+    assert len(decompose_goal_module._pending_auto_approvals) == 0
+
+
+# ---------------------------------------------------------------------------
+# cancel_auto_approve
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_cancel_auto_approve_cancels_pending_task(monkeypatch):
+    """Calling cancel_auto_approve should cancel the pending task and return True."""
+    monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 999)
+    fake_run = AsyncMock()
+    monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
+
+    session = make_session(_USER_ID)
+    _REAL_SCHEDULE_AUTO_APPROVE(
+        session_id="session-cancel-test",
+        user_id=_USER_ID,
+        session=session,
+    )
+
+    assert "session-cancel-test" in decompose_goal_module._pending_auto_approvals
+    result = cancel_auto_approve("session-cancel-test")
+    assert result is True
+    assert "session-cancel-test" not in decompose_goal_module._pending_auto_approvals
+
+
+def test_cancel_auto_approve_returns_false_for_unknown_session():
+    """Cancelling a session with no pending task should return False."""
+    assert cancel_auto_approve("nonexistent-session") is False
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index a4a6b509b8b6..b5123d8907f4 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import { postV2CancelAutoApproveTask } from "@/app/api/__generated__/endpoints/chat/chat";
 import { Button } from "@/components/atoms/Button/Button";
 import {
   CheckIcon,
@@ -166,7 +167,18 @@ export function DecomposeGoalTool({
     if (!output || !isDecompositionOutput(output)) return;
     setTimerActive(false);
     setIsEditing(true);
-    setEditableSteps(output.steps.map((s) => ({ ...s })));
+    setEditableSteps(
+      output.steps.map((s) => ({ ...s, status: s.status ?? "pending" })),
+    );
+
+    // Cancel the server-side auto-approve timer so it doesn't fire the
+    // default "Approved" message while the user is editing steps.
+    if (output.session_id) {
+      postV2CancelAutoApproveTask(output.session_id).catch(() => {
+        // Best-effort — if the timer already fired or the request fails,
+        // the predicate check will still prevent a duplicate.
+      });
+    }
   }
 
   function handleStepChange(index: number, description: string) {
@@ -321,7 +333,7 @@ export function DecomposeGoalTool({
                       index={i}
                       description={step.description}
                       blockName={step.block_name}
-                      status={step.status}
+                      status={step.status ?? "pending"}
                     />
                   ))}
                 </div>
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
index 8df68fe755aa..4da6e0457e4f 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -1,5 +1,6 @@
 "use client";
 
+import type { DecompositionStepModel } from "@/app/api/__generated__/models/decompositionStepModel";
 import {
   CheckCircleIcon,
   CircleDashedIcon,
@@ -11,25 +12,23 @@ import {
 import type { ToolUIPart } from "ai";
 import { ScaleLoader } from "../../components/ScaleLoader/ScaleLoader";
 
-interface DecompositionStep {
-  step_id: string;
-  description: string;
-  action: string;
-  block_name?: string | null;
-  status: string;
-}
+// Re-export generated step type for consumers that need it.
+export type DecompositionStep = DecompositionStepModel;
 
+// Hand-rolled because the tool output is parsed from opaque JSON (not through
+// the generated API client), so the runtime shape differs from the generated
+// TaskDecompositionResponse — notably ``created_at`` is an ISO 8601 string at
+// runtime, whereas the generated type declares ``Date``. Keep fields in sync
+// with backend ``TaskDecompositionResponse`` in tools/models.py.
 export interface TaskDecompositionOutput {
   type: string;
   message: string;
+  session_id?: string | null;
   goal: string;
   steps: DecompositionStep[];
   step_count: number;
   requires_approval: boolean;
   auto_approve_seconds?: number;
-  // ISO 8601 UTC timestamp stamped by the backend when the tool returned.
-  // Used to compute the actual remaining countdown when the user reopens
-  // the session, so the timer doesn't restart from full each time.
   created_at?: string;
 }
 
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 13ac3a86bf57..eedd89933497 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -1606,6 +1606,46 @@
         }
       }
     },
+    "/api/chat/sessions/{session_id}/cancel-auto-approve": {
+      "post": {
+        "tags": ["v2", "chat", "chat"],
+        "summary": "Cancel Auto Approve Task",
+        "description": "Cancel the pending auto-approve timer for a decompose_goal plan.\n\nCalled by the frontend when the user clicks \"Modify\" on the build-plan\nbox. Without this, the server-side timer would fire the default\n\"Approved\" message while the user is still editing.",
+        "operationId": "postV2CancelAutoApproveTask",
+        "security": [{ "HTTPBearerJWT": [] }],
+        "parameters": [
+          {
+            "name": "session_id",
+            "in": "path",
+            "required": true,
+            "schema": { "type": "string", "title": "Session Id" }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/CancelSessionResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/chat/sessions/{session_id}/stream": {
       "get": {
         "tags": ["v2", "chat", "chat"],

From b2dab8afad90c8bf2b6954a141aaa1ff5ad895ca Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 14 Apr 2026 20:34:58 +0200
Subject: [PATCH 23/61] fix(copilot): use Redis flag for cross-process
 auto-approve cancellation
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cancel endpoint runs in the AgentServer process while the asyncio
auto-approve task lives in the CoPilotExecutor process — separate memory.
The in-process dict cancel from the previous commit was a no-op across
processes.

- cancel_auto_approve now SETs a Redis key with TTL as the primary cancel
  signal, plus best-effort in-process task.cancel() for single-worker.
- _run_auto_approve checks the Redis key before firing. If set, skips.
- Tests stub get_redis_async with a fake to avoid real Redis connections.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/api/features/chat/routes.py       |  2 +-
 .../backend/copilot/tools/decompose_goal.py   | 56 +++++++++++++----
 .../copilot/tools/decompose_goal_test.py      | 63 +++++++++++++++++--
 3 files changed, 103 insertions(+), 18 deletions(-)

diff --git a/autogpt_platform/backend/backend/api/features/chat/routes.py b/autogpt_platform/backend/backend/api/features/chat/routes.py
index bfc9d45bfed6..28507bf5fa26 100644
--- a/autogpt_platform/backend/backend/api/features/chat/routes.py
+++ b/autogpt_platform/backend/backend/api/features/chat/routes.py
@@ -735,7 +735,7 @@ async def cancel_auto_approve_task(
 
     from backend.copilot.tools.decompose_goal import cancel_auto_approve
 
-    cancelled = cancel_auto_approve(session_id)
+    cancelled = await cancel_auto_approve(session_id)
     return CancelSessionResponse(
         cancelled=cancelled,
         reason=None if cancelled else "no_pending_auto_approve",
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 2ac82fc9b8d6..185cedacee05 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -6,6 +6,7 @@
 from uuid import uuid4
 
 from backend.copilot.model import ChatMessage, ChatSession, append_message_if
+from backend.data.redis_client import get_redis_async
 
 from .base import BaseTool
 from .models import (
@@ -29,9 +30,14 @@
 AUTO_APPROVE_SERVER_SECONDS = AUTO_APPROVE_CLIENT_SECONDS
 AUTO_APPROVE_MESSAGE = "Approved. Please build the agent."
 
-# Pending auto-approve tasks keyed by session_id. The dict allows
-# cancel_auto_approve() to look up and cancel the task for a specific
-# session when the user clicks "Modify" in the frontend.
+# Redis key prefix for cross-process cancel signalling. The cancel
+# endpoint (AgentServer process) SETs the key; _run_auto_approve
+# (CoPilotExecutor process) checks it before firing.
+_CANCEL_KEY_PREFIX = "copilot:cancel_auto_approve:"
+_CANCEL_KEY_TTL_SECONDS = AUTO_APPROVE_SERVER_SECONDS + 30
+
+# In-process dict for best-effort cancel when both the cancel call and
+# the asyncio task happen to live in the same process (single-worker).
 _pending_auto_approvals: dict[str, asyncio.Task] = {}
 
 
@@ -77,6 +83,15 @@ async def _run_auto_approve(
     try:
         await asyncio.sleep(AUTO_APPROVE_SERVER_SECONDS)
 
+        # Check the cross-process cancel flag set by cancel_auto_approve().
+        redis = await get_redis_async()
+        if await redis.get(f"{_CANCEL_KEY_PREFIX}{session_id}"):
+            logger.info(
+                "decompose_goal auto-approve skipped (cancelled) for session %s",
+                session_id,
+            )
+            return
+
         approval = ChatMessage(role="user", content=AUTO_APPROVE_MESSAGE)
         result = await append_message_if(
             session_id=session_id,
@@ -117,19 +132,35 @@ async def _run_auto_approve(
         )
 
 
-def cancel_auto_approve(session_id: str) -> bool:
+async def cancel_auto_approve(session_id: str) -> bool:
     """Cancel the pending auto-approve task for a session.
 
     Called by the ``/sessions/{session_id}/cancel-auto-approve`` endpoint
-    when the user clicks "Modify" in the build-plan UI. Returns True if a
-    pending task was found and cancelled, False otherwise.
+    when the user clicks "Modify" in the build-plan UI.
+
+    Uses **two** cancellation channels:
+    1. **Redis flag** (cross-process) — the executor checks this before
+       firing. Works even when the cancel endpoint runs in the AgentServer
+       process and the asyncio task lives in the CoPilotExecutor process.
+    2. **In-process task cancel** (best-effort) — if both happen to share
+       the same process, cancels the asyncio task directly.
     """
+    redis = await get_redis_async()
+    await redis.set(
+        f"{_CANCEL_KEY_PREFIX}{session_id}",
+        "1",
+        ex=_CANCEL_KEY_TTL_SECONDS,
+    )
+    logger.info(
+        "decompose_goal auto-approve cancel flag set for session %s", session_id
+    )
+
+    # Best-effort in-process cancel (no-op if the task is in another process).
     task = _pending_auto_approvals.pop(session_id, None)
     if task is not None and not task.done():
         task.cancel()
-        logger.info("decompose_goal auto-approve cancelled for session %s", session_id)
-        return True
-    return False
+
+    return True
 
 
 def _schedule_auto_approve(
@@ -145,8 +176,11 @@ def _schedule_auto_approve(
     if not session_id:
         return
     # Cancel any existing pending approval for this session (e.g. if the
-    # LLM called decompose_goal twice in one turn).
-    cancel_auto_approve(session_id)
+    # LLM called decompose_goal twice in one turn). Best-effort in-process
+    # cancel only — skip the async Redis call here to keep scheduling fast.
+    old_task = _pending_auto_approvals.pop(session_id, None)
+    if old_task is not None and not old_task.done():
+        old_task.cancel()
     baseline_index = len(session.messages)
     task = asyncio.create_task(_run_auto_approve(session_id, user_id, baseline_index))
     _pending_auto_approvals[session_id] = task
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index 1498f7810488..514114b43c2e 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -381,6 +381,24 @@ def test_predicate_handles_messages_with_none_sequence():
 # ---------------------------------------------------------------------------
 
 
+class _FakeRedisNoCancelFlag:
+    """Stub Redis that reports no cancel flag and ignores writes."""
+
+    async def get(self, key):
+        return None
+
+    async def set(self, key, value, ex=None):
+        pass
+
+
+def _stub_redis():
+    """Patch get_redis_async to return a fake Redis (no real connection)."""
+    return patch(
+        "backend.copilot.tools.decompose_goal.get_redis_async",
+        new=AsyncMock(return_value=_FakeRedisNoCancelFlag()),
+    )
+
+
 @pytest.mark.asyncio
 async def test_auto_approve_fires_when_user_idle():
     """When no user message is appended after the baseline sequence, the
@@ -397,6 +415,7 @@ async def fake_append_message_if(session_id, message, predicate):
     fake_create_session = AsyncMock()
 
     with (
+        _stub_redis(),
         patch(
             "backend.copilot.tools.decompose_goal.append_message_if",
             new=fake_append_message_if,
@@ -440,6 +459,7 @@ async def test_auto_approve_skips_when_user_already_acted():
     fake_create_session = AsyncMock()
 
     with (
+        _stub_redis(),
         patch(
             "backend.copilot.tools.decompose_goal.append_message_if",
             new=fake_append_message_if,
@@ -477,6 +497,7 @@ async def boom(*args, **kwargs):
         raise RuntimeError("kaboom")
 
     with (
+        _stub_redis(),
         patch(
             "backend.copilot.tools.decompose_goal.append_message_if",
             new=boom,
@@ -538,12 +559,26 @@ def test_schedule_auto_approve_no_op_without_session_id():
 
 
 @pytest.mark.asyncio
-async def test_cancel_auto_approve_cancels_pending_task(monkeypatch):
-    """Calling cancel_auto_approve should cancel the pending task and return True."""
+async def test_cancel_auto_approve_sets_redis_flag_and_cancels_task(monkeypatch):
+    """cancel_auto_approve should set a Redis cancel flag AND cancel the
+    in-process task. Returns True always (Redis flag is authoritative)."""
     monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 999)
     fake_run = AsyncMock()
     monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
 
+    captured_redis_calls: list[tuple] = []
+
+    class FakeRedis:
+        async def set(self, key, value, ex=None):
+            captured_redis_calls.append(("set", key, value, ex))
+
+        async def get(self, key):
+            return None
+
+    monkeypatch.setattr(
+        decompose_goal_module, "get_redis_async", AsyncMock(return_value=FakeRedis())
+    )
+
     session = make_session(_USER_ID)
     _REAL_SCHEDULE_AUTO_APPROVE(
         session_id="session-cancel-test",
@@ -552,11 +587,27 @@ async def test_cancel_auto_approve_cancels_pending_task(monkeypatch):
     )
 
     assert "session-cancel-test" in decompose_goal_module._pending_auto_approvals
-    result = cancel_auto_approve("session-cancel-test")
+    result = await cancel_auto_approve("session-cancel-test")
     assert result is True
     assert "session-cancel-test" not in decompose_goal_module._pending_auto_approvals
+    assert len(captured_redis_calls) == 1
+    assert captured_redis_calls[0][0] == "set"
+    assert "session-cancel-test" in captured_redis_calls[0][1]
 
 
-def test_cancel_auto_approve_returns_false_for_unknown_session():
-    """Cancelling a session with no pending task should return False."""
-    assert cancel_auto_approve("nonexistent-session") is False
+@pytest.mark.asyncio
+async def test_cancel_auto_approve_returns_true_even_without_in_process_task(
+    monkeypatch,
+):
+    """Even if no in-process task exists (e.g. task is in another process),
+    cancel_auto_approve should still set the Redis flag and return True."""
+
+    class FakeRedis:
+        async def set(self, key, value, ex=None):
+            pass
+
+    monkeypatch.setattr(
+        decompose_goal_module, "get_redis_async", AsyncMock(return_value=FakeRedis())
+    )
+    result = await cancel_auto_approve("nonexistent-session")
+    assert result is True

From 5f19f6ca23abcc23c7b6f95b6e64ebcabbfd5648 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 14 Apr 2026 21:33:47 +0200
Subject: [PATCH 24/61] fix(copilot): remove client-side auto-approve to
 prevent duplicate messages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Both the client and server fired "Approved. Please build the agent." at
~60s, producing two messages and two agent-build turns.

The server-side timer is now the sole auto-approver. The client countdown
is purely visual — when it hits 0, the server's synthetic message arrives
via SSE. User clicks (Start now / Approve in edit mode) still call
approve() directly and send the message; the server's predicate sees
the user message and skips its own.

Removes wasInitiallyPastDeadlineRef (no longer needed since the client
never fires auto-approve on its own) and the auto-approve useEffect.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 38 +++----------------
 1 file changed, 5 insertions(+), 33 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index b5123d8907f4..6b3800156e8d 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -120,20 +120,6 @@ export function DecomposeGoalTool({
   const [isEditing, setIsEditing] = useState(false);
   const [editableSteps, setEditableSteps] = useState<EditableStep[]>([]);
 
-  // True iff the lazy initializer above already returned 0 because the
-  // server-stamped deadline had elapsed before the user reopened the tab.
-  // The auto-approve effect uses this to avoid silently approving on mount
-  // — the server's own fallback timer will handle it within ~30s, and
-  // skipping the silent fire gives the user a chance to click Modify
-  // instead. Without this guard, reopening between 60-90s after creation
-  // would auto-approve with no interaction.
-  const wasInitiallyPastDeadlineRef = useRef(
-    secondsLeft === 0 &&
-      !!output &&
-      isDecompositionOutput(output) &&
-      !!output.created_at,
-  );
-
   const approvedRef = useRef(false);
   const onSendRef = useRef(onSend);
   const isEditingRef = useRef(isEditing);
@@ -221,25 +207,11 @@ export function DecomposeGoalTool({
     return () => clearInterval(interval);
   }, [showActions, timerActive, part.toolCallId]);
 
-  // Auto-approve when countdown reaches 0 — but only after the assistant
-  // has finished streaming its summary text, AND only if the timer
-  // actually counted down (not if it started at 0 because the deadline
-  // had already passed when the user reopened the tab). Firing on mount
-  // in the past-deadline case would silently approve without giving the
-  // user a chance to click Modify; the server's fallback timer covers
-  // that scenario instead. If the timer hits 0 mid-stream, this effect
-  // re-runs when actionsEnabled flips true. approve() is stable via
-  // approvedRef — safe to omit from deps.
-  useEffect(() => {
-    if (
-      secondsLeft === 0 &&
-      timerActive &&
-      actionsEnabled &&
-      !wasInitiallyPastDeadlineRef.current
-    ) {
-      approve();
-    }
-  }, [secondsLeft, timerActive, actionsEnabled]); // approve reads refs only — safe to omit
+  // The server-side timer is the sole auto-approver (sends the synthetic
+  // "Approved" message and enqueues the next copilot turn). The client
+  // countdown is purely visual — no client-side approve() call when it
+  // hits 0. This avoids the duplicate-message bug where both client and
+  // server fire at ~60s. User clicks (Start now / Approve) still work.
 
   const progress = secondsLeft / countdownSeconds;
   const dashOffset = CIRCUMFERENCE * (1 - progress);

From 0840b565e33b8f20f96f6900ef59b4203b323401 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 14 Apr 2026 22:01:26 +0200
Subject: [PATCH 25/61] fix(copilot): clear stale Redis cancel flag when
 scheduling new auto-approve

Sentry correctly identified that after a user clicks Modify (which sets
a Redis cancel flag) and then the LLM calls decompose_goal again for a
new plan, the stale cancel flag would suppress the new auto-approve.

_schedule_auto_approve is now async and DELETEs the Redis cancel key
before scheduling the new task. Also fixes the autouse test fixture to
use an async no-op (matching the now-async function signature).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py   | 11 +++++---
 .../copilot/tools/decompose_goal_test.py      | 28 ++++++++++++++-----
 2 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 185cedacee05..cb2f33e855d8 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -163,7 +163,7 @@ async def cancel_auto_approve(session_id: str) -> bool:
     return True
 
 
-def _schedule_auto_approve(
+async def _schedule_auto_approve(
     session_id: str | None, user_id: str | None, session: ChatSession
 ) -> None:
     """Schedule the fire-and-forget auto-approve task for this session.
@@ -176,11 +176,14 @@ def _schedule_auto_approve(
     if not session_id:
         return
     # Cancel any existing pending approval for this session (e.g. if the
-    # LLM called decompose_goal twice in one turn). Best-effort in-process
-    # cancel only — skip the async Redis call here to keep scheduling fast.
+    # LLM called decompose_goal twice in one turn).
     old_task = _pending_auto_approvals.pop(session_id, None)
     if old_task is not None and not old_task.done():
         old_task.cancel()
+    # Clear any stale Redis cancel flag from a previous Modify click so
+    # the new auto-approve task isn't incorrectly suppressed.
+    redis = await get_redis_async()
+    await redis.delete(f"{_CANCEL_KEY_PREFIX}{session_id}")
     baseline_index = len(session.messages)
     task = asyncio.create_task(_run_auto_approve(session_id, user_id, baseline_index))
     _pending_auto_approvals[session_id] = task
@@ -301,7 +304,7 @@ async def _execute(
                 )
             )
 
-        _schedule_auto_approve(session_id, user_id, session)
+        await _schedule_auto_approve(session_id, user_id, session)
 
         return TaskDecompositionResponse(
             message=f"Here's the plan to build your agent ({len(decomposition_steps)} steps):",
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index 514114b43c2e..e234aa3a5f54 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -42,9 +42,11 @@ def _stub_auto_approve_scheduler():
     fire-and-forget scheduler so they don't kick off real timers that try to
     hit Redis/Postgres. Tests that exercise auto-approve override this with
     their own patches inside the test body."""
-    with patch.object(
-        decompose_goal_module, "_schedule_auto_approve", lambda *a, **kw: None
-    ):
+
+    async def _noop(*a, **kw):
+        pass
+
+    with patch.object(decompose_goal_module, "_schedule_auto_approve", _noop):
         yield
 
 
@@ -390,6 +392,9 @@ async def get(self, key):
     async def set(self, key, value, ex=None):
         pass
 
+    async def delete(self, key):
+        pass
+
 
 def _stub_redis():
     """Patch get_redis_async to return a fake Redis (no real connection)."""
@@ -523,6 +528,11 @@ async def test_schedule_auto_approve_creates_task(monkeypatch):
     monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 0)
     fake_run = AsyncMock()
     monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
+    monkeypatch.setattr(
+        decompose_goal_module,
+        "get_redis_async",
+        AsyncMock(return_value=_FakeRedisNoCancelFlag()),
+    )
 
     session = make_session(_USER_ID)
     # Two messages already in the session — the next one (the tool result)
@@ -530,7 +540,7 @@ async def test_schedule_auto_approve_creates_task(monkeypatch):
     session.messages.append(ChatMessage(role="user", content="initial"))
     session.messages.append(ChatMessage(role="assistant", content="tool call"))
 
-    _REAL_SCHEDULE_AUTO_APPROVE(
+    await _REAL_SCHEDULE_AUTO_APPROVE(
         session_id="session-schedule",
         user_id=_USER_ID,
         session=session,
@@ -544,10 +554,11 @@ async def test_schedule_auto_approve_creates_task(monkeypatch):
     fake_run.assert_awaited_once_with("session-schedule", _USER_ID, 2)
 
 
-def test_schedule_auto_approve_no_op_without_session_id():
+@pytest.mark.asyncio
+async def test_schedule_auto_approve_no_op_without_session_id():
     """Empty session id should be a no-op (defensive)."""
     session = make_session(_USER_ID)
-    decompose_goal_module._schedule_auto_approve(
+    await decompose_goal_module._schedule_auto_approve(
         session_id=None, user_id=_USER_ID, session=session
     )
     assert len(decompose_goal_module._pending_auto_approvals) == 0
@@ -575,12 +586,15 @@ async def set(self, key, value, ex=None):
         async def get(self, key):
             return None
 
+        async def delete(self, key):
+            pass
+
     monkeypatch.setattr(
         decompose_goal_module, "get_redis_async", AsyncMock(return_value=FakeRedis())
     )
 
     session = make_session(_USER_ID)
-    _REAL_SCHEDULE_AUTO_APPROVE(
+    await _REAL_SCHEDULE_AUTO_APPROVE(
         session_id="session-cancel-test",
         user_id=_USER_ID,
         session=session,

From d892b66580f8a7240dc7250f63d06130bff3e079 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 14 Apr 2026 22:36:41 +0200
Subject: [PATCH 26/61] fix(copilot): fall back to default approval when all
 step descriptions are empty
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If the user cleared all step descriptions without deleting the steps,
buildMessage() produced "Approved with modifications. Please build the
agent following these steps: " — a dangling colon with no actual steps.
Now falls back to the standard "Approved. Please build the agent." when
filledSteps is empty after filtering.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/tools/DecomposeGoal/DecomposeGoal.tsx      | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 6b3800156e8d..25c302ce5e9e 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -133,10 +133,12 @@ export function DecomposeGoalTool({
       const filledSteps = editableStepsRef.current.filter((s) =>
         s.description.trim(),
       );
-      const list = filledSteps
-        .map((s, i) => `${i + 1}. ${s.description}`)
-        .join("; ");
-      return `Approved with modifications. Please build the agent following these steps: ${list}`;
+      if (filledSteps.length > 0) {
+        const list = filledSteps
+          .map((s, i) => `${i + 1}. ${s.description}`)
+          .join("; ");
+        return `Approved with modifications. Please build the agent following these steps: ${list}`;
+      }
     }
     return "Approved. Please build the agent.";
   }

From 6d1cd41c43e5cb12283d56a144e51c8368c6258b Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 14 Apr 2026 23:21:44 +0200
Subject: [PATCH 27/61] fix(copilot): restore client auto-approve with 5s
 server grace to fix UI not updating
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When the server was the sole auto-approver (both at 60s, client removed),
users who stayed in the session saw nothing happen — the server fired
the turn but the frontend had no SSE subscription to receive the events.

Restore the client-side auto-approve effect so it fires at 60s (creating
the SSE subscription), and add a 5s server grace (server fires at 65s).
When the client IS present, it fires first → SSE → user sees the build.
The server wakes 5s later, sees the client's message, skips. When the
client is gone (tab closed), the server fires at 65s as the fallback.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py      | 12 ++++++++----
 .../tools/DecomposeGoal/DecomposeGoal.tsx        | 16 +++++++++++-----
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index cb2f33e855d8..ff1feadd3bdd 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -23,11 +23,15 @@
 DEFAULT_ACTION = "add_block"
 VALID_ACTIONS = {"add_block", "connect_blocks", "configure", "add_input", "add_output"}
 
-# Auto-approve countdown — single source of truth for both client and server.
-# The frontend reads ``auto_approve_seconds`` from the tool response and runs
-# the visible countdown. The server fires at the same deadline.
+# Auto-approve countdown — the frontend reads ``auto_approve_seconds`` from the
+# tool response and runs the visible countdown (60s). The server fires 5s later
+# as a fallback for the "user closed the tab" case. The 5s gap ensures the
+# client always fires first when present, creating the SSE subscription that
+# lets the user see the build in real-time. When the server wakes at 65s, it
+# checks the predicate and skips (the client's message is already there).
 AUTO_APPROVE_CLIENT_SECONDS = 60
-AUTO_APPROVE_SERVER_SECONDS = AUTO_APPROVE_CLIENT_SECONDS
+AUTO_APPROVE_SERVER_GRACE_SECONDS = 5
+AUTO_APPROVE_SERVER_SECONDS = AUTO_APPROVE_CLIENT_SECONDS + AUTO_APPROVE_SERVER_GRACE_SECONDS
 AUTO_APPROVE_MESSAGE = "Approved. Please build the agent."
 
 # Redis key prefix for cross-process cancel signalling. The cancel
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 25c302ce5e9e..f7129e7f52e1 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -209,11 +209,17 @@ export function DecomposeGoalTool({
     return () => clearInterval(interval);
   }, [showActions, timerActive, part.toolCallId]);
 
-  // The server-side timer is the sole auto-approver (sends the synthetic
-  // "Approved" message and enqueues the next copilot turn). The client
-  // countdown is purely visual — no client-side approve() call when it
-  // hits 0. This avoids the duplicate-message bug where both client and
-  // server fire at ~60s. User clicks (Start now / Approve) still work.
+  // Auto-approve when countdown reaches 0. The client fires at 60s; the
+  // server fires 5s later as a fallback for the "user closed the tab" case.
+  // When the client IS present, its approve() creates the SSE subscription
+  // so the user sees the build in real-time. The server's predicate then
+  // sees the user's message and skips — no duplicate.
+  // approve() is stable via approvedRef — safe to omit from deps.
+  useEffect(() => {
+    if (secondsLeft === 0 && timerActive && actionsEnabled) {
+      approve();
+    }
+  }, [secondsLeft, timerActive, actionsEnabled]);
 
   const progress = secondsLeft / countdownSeconds;
   const dashOffset = CIRCUMFERENCE * (1 - progress);

From aa5b84e13c10865466d7d9f9be096aaadaa014e5 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 14 Apr 2026 23:40:44 +0200
Subject: [PATCH 28/61] style(copilot): reformat auto-approve constants

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/backend/copilot/tools/decompose_goal.py           | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index ff1feadd3bdd..925336a9a30c 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -31,7 +31,9 @@
 # checks the predicate and skips (the client's message is already there).
 AUTO_APPROVE_CLIENT_SECONDS = 60
 AUTO_APPROVE_SERVER_GRACE_SECONDS = 5
-AUTO_APPROVE_SERVER_SECONDS = AUTO_APPROVE_CLIENT_SECONDS + AUTO_APPROVE_SERVER_GRACE_SECONDS
+AUTO_APPROVE_SERVER_SECONDS = (
+    AUTO_APPROVE_CLIENT_SECONDS + AUTO_APPROVE_SERVER_GRACE_SECONDS
+)
 AUTO_APPROVE_MESSAGE = "Approved. Please build the agent."
 
 # Redis key prefix for cross-process cancel signalling. The cancel

From 020d094381b56657a616466079b78f06c1a6c302 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 15 Apr 2026 02:56:18 +0200
Subject: [PATCH 29/61] fix(copilot): prevent duplicate auto-approve via
 DB-backed predicate + remount guard
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Two "Approved" messages appeared because:

1. Server-side: append_message_if read the session from Redis cache, but
   the executor's upsert_chat_session during the build could overwrite
   the cache with an in-memory copy missing the client's "Approved".
   Fix: read from DB directly (_get_session_from_db) — the DB is the
   source of truth and is never overwritten by cache upserts.

2. Client-side: approvedRef resets on remount, so re-entering after the
   deadline fired approve() again from stale data.
   Fix: wasInitiallyPastDeadlineRef skips auto-approve when secondsLeft
   starts at 0 due to an already-elapsed deadline — the server handles it.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/backend/copilot/model.py           |  6 +++++-
 .../tools/DecomposeGoal/DecomposeGoal.tsx      | 18 +++++++++++++++++-
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/model.py b/autogpt_platform/backend/backend/copilot/model.py
index 4fc703063fd5..d669a9892a8b 100644
--- a/autogpt_platform/backend/backend/copilot/model.py
+++ b/autogpt_platform/backend/backend/copilot/model.py
@@ -696,7 +696,11 @@ async def append_message_if(
     lock = await _get_session_lock(session_id)
 
     async with lock:
-        session = await get_chat_session(session_id)
+        # Read from DB directly — the Redis cache can be stale because the
+        # executor's upsert_chat_session overwrites it with in-memory copies
+        # during streaming, which may not include messages appended by the
+        # API server in a different process (e.g. the client's "Approved").
+        session = await _get_session_from_db(session_id)
         if session is None or not predicate(session):
             return None
 
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index f7129e7f52e1..e36e35af6a41 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -120,6 +120,17 @@ export function DecomposeGoalTool({
   const [isEditing, setIsEditing] = useState(false);
   const [editableSteps, setEditableSteps] = useState<EditableStep[]>([]);
 
+  // True when secondsLeft started at 0 because the server-stamped deadline
+  // had already elapsed before this mount. Prevents the auto-approve effect
+  // from firing on remount with stale cache — the server handles that case.
+  // Without this, re-entering after the deadline sends a duplicate "Approved".
+  const wasInitiallyPastDeadlineRef = useRef(
+    secondsLeft === 0 &&
+      !!output &&
+      isDecompositionOutput(output) &&
+      !!output.created_at,
+  );
+
   const approvedRef = useRef(false);
   const onSendRef = useRef(onSend);
   const isEditingRef = useRef(isEditing);
@@ -216,7 +227,12 @@ export function DecomposeGoalTool({
   // sees the user's message and skips — no duplicate.
   // approve() is stable via approvedRef — safe to omit from deps.
   useEffect(() => {
-    if (secondsLeft === 0 && timerActive && actionsEnabled) {
+    if (
+      secondsLeft === 0 &&
+      timerActive &&
+      actionsEnabled &&
+      !wasInitiallyPastDeadlineRef.current
+    ) {
       approve();
     }
   }, [secondsLeft, timerActive, actionsEnabled]);

From 8d102d6eebb83764bf110e85a2ca6791b91f6fbc Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 15 Apr 2026 03:00:05 +0200
Subject: [PATCH 30/61] refactor(copilot): remove max 8 steps limit from
 decompose_goal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The step count is now unrestricted — the LLM can decompose goals into
as many steps as needed. Removes MAX_STEPS constant, the too_many_steps
validation, and the two related tests.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/sdk/agent_generation_guide.md     |  2 +-
 .../backend/copilot/tools/decompose_goal.py   |  9 -----
 .../copilot/tools/decompose_goal_test.py      | 33 -------------------
 3 files changed, 1 insertion(+), 43 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
index 00750e3b1f7b..efa3ebeed384 100644
--- a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
+++ b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
@@ -37,7 +37,7 @@ Before running the workflow below, ALWAYS decompose the goal first:
 4. Only after approval, continue with "Workflow for Creating/Editing Agents".
 
 For simple goals (1-2 blocks), keep steps brief (2-3 steps).
-For complex goals, decompose into 4-8 steps max.
+For complex goals, use as many steps as needed.
 
 ### Workflow for Creating/Editing Agents
 
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 925336a9a30c..36d7f1d4f971 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -18,8 +18,6 @@
 
 logger = logging.getLogger(__name__)
 
-# Matches the guide's "4-8 steps max" constraint.
-MAX_STEPS = 8
 DEFAULT_ACTION = "add_block"
 VALID_ACTIONS = {"add_block", "connect_blocks", "configure", "add_input", "add_output"}
 
@@ -275,13 +273,6 @@ async def _execute(
                 session_id=session_id,
             )
 
-        if len(steps) > MAX_STEPS:
-            return ErrorResponse(
-                message=f"Too many steps ({len(steps)}). Keep the plan to {MAX_STEPS} steps max.",
-                error="too_many_steps",
-                session_id=session_id,
-            )
-
         decomposition_steps: list[DecompositionStepModel] = []
         for i, step in enumerate(steps):
             if not isinstance(step, dict):
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index e234aa3a5f54..51d99d0434d7 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -13,7 +13,6 @@
 from .decompose_goal import (
     AUTO_APPROVE_CLIENT_SECONDS,
     DEFAULT_ACTION,
-    MAX_STEPS,
     DecomposeGoalTool,
     _no_user_action_since,
     cancel_auto_approve,
@@ -190,38 +189,6 @@ async def test_empty_steps_returns_error(tool: DecomposeGoalTool, session):
     assert result.error == "missing_steps"
 
 
-@pytest.mark.asyncio
-async def test_too_many_steps_returns_error(tool: DecomposeGoalTool, session):
-    many_steps = [
-        {"description": f"Step {i}", "action": "add_block"}
-        for i in range(MAX_STEPS + 1)
-    ]
-    result = await tool._execute(
-        user_id=_USER_ID,
-        session=session,
-        goal="Over-engineered agent",
-        steps=many_steps,
-    )
-    assert isinstance(result, ErrorResponse)
-    assert result.error == "too_many_steps"
-
-
-@pytest.mark.asyncio
-async def test_exactly_max_steps_succeeds(tool: DecomposeGoalTool, session):
-    """Exactly MAX_STEPS steps should succeed."""
-    max_steps = [
-        {"description": f"Step {i}", "action": "add_block"} for i in range(MAX_STEPS)
-    ]
-    result = await tool._execute(
-        user_id=_USER_ID,
-        session=session,
-        goal="Complex agent",
-        steps=max_steps,
-    )
-    assert isinstance(result, TaskDecompositionResponse)
-    assert len(result.steps) == MAX_STEPS
-
-
 # ---------------------------------------------------------------------------
 # Validation — malformed step items
 # ---------------------------------------------------------------------------

From bee1c9a3bbf3d3a5ea112f40d8ec5f5f108c2d7f Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 15 Apr 2026 18:38:44 +0200
Subject: [PATCH 31/61] fix(copilot): resolve merge conflict with dev + improve
 frontend test coverage

- Resolve merge conflict in routes.py (keep both TaskDecompositionResponse
  and Memory*Response types) and openapi.json (re-exported from backend)
- Move computeRemainingSeconds from DecomposeGoal.tsx to helpers.tsx so
  it's testable as a pure function
- Add 9 tests for computeRemainingSeconds covering: null/error output,
  missing/unparseable created_at, correct remaining calculation, zero
  clamp when deadline passed, total clamp for future timestamps, and
  fallback when auto_approve_seconds is missing

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 28 +-----
 .../DecomposeGoal/__tests__/helpers.test.ts   | 89 ++++++++++++++++++-
 .../copilot/tools/DecomposeGoal/helpers.tsx   | 27 ++++++
 3 files changed, 117 insertions(+), 27 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index e36e35af6a41..b00430391a9f 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -21,43 +21,19 @@ import { ToolErrorCard } from "../../components/ToolErrorCard/ToolErrorCard";
 import { StepItem } from "./components/StepItem";
 import {
   AccordionIcon,
+  computeRemainingSeconds,
   getAnimationText,
   getDecomposeGoalOutput,
   isDecompositionOutput,
   isErrorOutput,
+  FALLBACK_COUNTDOWN_SECONDS,
   ToolIcon,
   type DecomposeGoalOutput,
 } from "./helpers";
 
-// Fallback used only if the backend response omits auto_approve_seconds
-// (older sessions). The authoritative value comes from the tool output.
-const FALLBACK_COUNTDOWN_SECONDS = 60;
 const RADIUS = 15;
 const CIRCUMFERENCE = 2 * Math.PI * RADIUS;
 
-/**
- * Compute remaining countdown seconds, deriving elapsed time from the
- * backend-stamped ``created_at`` so the timer reflects real elapsed time
- * when the user reopens the session — instead of restarting from full.
- *
- * Falls back to the full countdown when ``created_at`` is missing (older
- * sessions stored before this field existed) or unparseable. Clamps to
- * ``[0, total]`` to defend against client clock skew producing future
- * timestamps.
- */
-function computeRemainingSeconds(
-  output: DecomposeGoalOutput | null,
-  fallback: number,
-): number {
-  if (!output || !isDecompositionOutput(output)) return fallback;
-  const total = output.auto_approve_seconds ?? fallback;
-  if (!output.created_at) return total;
-  const createdAtMs = new Date(output.created_at).getTime();
-  if (Number.isNaN(createdAtMs)) return total;
-  const elapsedSec = (Date.now() - createdAtMs) / 1000;
-  return Math.max(0, Math.min(total, Math.round(total - elapsedSec)));
-}
-
 interface EditableStep {
   step_id: string;
   description: string;
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
index 80c9f835adeb..fc26c90161e4 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
@@ -4,8 +4,10 @@
  * Covers: parseOutput / getDecomposeGoalOutput, type guards, getAnimationText
  */
 
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import {
+  computeRemainingSeconds,
+  FALLBACK_COUNTDOWN_SECONDS,
   getAnimationText,
   getDecomposeGoalOutput,
   isDecompositionOutput,
@@ -206,3 +208,88 @@ describe("getAnimationText", () => {
     expect(text.toLowerCase()).toContain("analyzing");
   });
 });
+
+// ---------------------------------------------------------------------------
+// computeRemainingSeconds
+// ---------------------------------------------------------------------------
+
+const DECOMPOSITION_BASE: TaskDecompositionOutput = {
+  type: "task_decomposition",
+  message: "Plan",
+  goal: "Build agent",
+  steps: [{ step_id: "s1", description: "Step 1", action: "add_block" }],
+  step_count: 1,
+  requires_approval: true,
+  auto_approve_seconds: 60,
+  created_at: new Date().toISOString(),
+};
+
+describe("computeRemainingSeconds", () => {
+  it("returns fallback when output is null", () => {
+    expect(computeRemainingSeconds(null, 60)).toBe(60);
+  });
+
+  it("returns fallback when output is an error", () => {
+    const err: DecomposeErrorOutput = { type: "error", error: "oops" };
+    expect(computeRemainingSeconds(err, 60)).toBe(60);
+  });
+
+  it("returns auto_approve_seconds when created_at is missing", () => {
+    const noTimestamp = { ...DECOMPOSITION_BASE, created_at: undefined };
+    expect(computeRemainingSeconds(noTimestamp, 99)).toBe(60);
+  });
+
+  it("returns auto_approve_seconds when created_at is unparseable", () => {
+    const badTimestamp = { ...DECOMPOSITION_BASE, created_at: "not-a-date" };
+    expect(computeRemainingSeconds(badTimestamp, 99)).toBe(60);
+  });
+
+  it("returns correct remaining seconds for a recent timestamp", () => {
+    vi.useFakeTimers();
+    const now = new Date("2026-01-01T00:00:30Z");
+    vi.setSystemTime(now);
+    const output = {
+      ...DECOMPOSITION_BASE,
+      created_at: "2026-01-01T00:00:00Z",
+    };
+    // 30s elapsed → 60 - 30 = 30
+    expect(computeRemainingSeconds(output, 60)).toBe(30);
+    vi.useRealTimers();
+  });
+
+  it("clamps to 0 when deadline has passed", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-01-01T00:02:00Z"));
+    const output = {
+      ...DECOMPOSITION_BASE,
+      created_at: "2026-01-01T00:00:00Z",
+    };
+    expect(computeRemainingSeconds(output, 60)).toBe(0);
+    vi.useRealTimers();
+  });
+
+  it("clamps to total when client clock is ahead (future timestamp)", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-01-01T00:00:00Z"));
+    const output = {
+      ...DECOMPOSITION_BASE,
+      created_at: "2026-01-01T00:00:10Z",
+    };
+    // elapsed = -10 → total - (-10) = 70, clamped to 60
+    expect(computeRemainingSeconds(output, 60)).toBe(60);
+    vi.useRealTimers();
+  });
+
+  it("uses fallback when auto_approve_seconds is missing", () => {
+    const noAutoApprove = {
+      ...DECOMPOSITION_BASE,
+      auto_approve_seconds: undefined,
+      created_at: undefined,
+    };
+    expect(computeRemainingSeconds(noAutoApprove, 42)).toBe(42);
+  });
+
+  it("exports FALLBACK_COUNTDOWN_SECONDS as 60", () => {
+    expect(FALLBACK_COUNTDOWN_SECONDS).toBe(60);
+  });
+});
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
index 4da6e0457e4f..f8b3cd23203b 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -42,6 +42,33 @@ export type DecomposeGoalOutput =
   | TaskDecompositionOutput
   | DecomposeErrorOutput;
 
+// Fallback used only if the backend response omits auto_approve_seconds
+// (older sessions). The authoritative value comes from the tool output.
+export const FALLBACK_COUNTDOWN_SECONDS = 60;
+
+/**
+ * Compute remaining countdown seconds, deriving elapsed time from the
+ * backend-stamped ``created_at`` so the timer reflects real elapsed time
+ * when the user reopens the session — instead of restarting from full.
+ *
+ * Falls back to the full countdown when ``created_at`` is missing (older
+ * sessions stored before this field existed) or unparseable. Clamps to
+ * ``[0, total]`` to defend against client clock skew producing future
+ * timestamps.
+ */
+export function computeRemainingSeconds(
+  output: DecomposeGoalOutput | null,
+  fallback: number,
+): number {
+  if (!output || !isDecompositionOutput(output)) return fallback;
+  const total = output.auto_approve_seconds ?? fallback;
+  if (!output.created_at) return total;
+  const createdAtMs = new Date(output.created_at).getTime();
+  if (Number.isNaN(createdAtMs)) return total;
+  const elapsedSec = (Date.now() - createdAtMs) / 1000;
+  return Math.max(0, Math.min(total, Math.round(total - elapsedSec)));
+}
+
 function parseOutput(output: unknown): DecomposeGoalOutput | null {
   if (!output) return null;
   if (typeof output === "string") {

From ffdafccc35ecb1093f6dd699e3b7dd0ac3f8a44a Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 15 Apr 2026 18:52:00 +0200
Subject: [PATCH 32/61] fix(frontend): remove unused DecomposeGoalOutput type
 import

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index b00430391a9f..fdf3328ca1f7 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -28,7 +28,6 @@ import {
   isErrorOutput,
   FALLBACK_COUNTDOWN_SECONDS,
   ToolIcon,
-  type DecomposeGoalOutput,
 } from "./helpers";
 
 const RADIUS = 15;

From 35bca7c7adbae13a3428d5cb755ae42473f4cfb3 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 15 Apr 2026 19:09:48 +0200
Subject: [PATCH 33/61] fix(copilot): fix task callback race + skip redundant
 DB existence check

1. The done_callback on a cancelled old task would pop the new task from
   _pending_auto_approvals (same session_id key). Now checks identity
   before removing.
2. append_message_if passes skip_existence_check=True to _save_session_to_db
   since the session was already loaded from DB.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 autogpt_platform/backend/backend/copilot/model.py      |  6 +++++-
 .../backend/backend/copilot/tools/decompose_goal.py    | 10 +++++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/model.py b/autogpt_platform/backend/backend/copilot/model.py
index efd0df32742d..fdde7fcddfdb 100644
--- a/autogpt_platform/backend/backend/copilot/model.py
+++ b/autogpt_platform/backend/backend/copilot/model.py
@@ -714,7 +714,11 @@ async def append_message_if(
         existing_message_count = await chat_db().get_next_sequence(session_id)
 
         try:
-            await _save_session_to_db(session, existing_message_count)
+            await _save_session_to_db(
+                session,
+                existing_message_count,
+                skip_existence_check=True,
+            )
         except Exception as e:
             logger.error(
                 f"append_message_if: failed to persist message to "
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 36d7f1d4f971..d9c6e5b265f7 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -191,7 +191,15 @@ async def _schedule_auto_approve(
     baseline_index = len(session.messages)
     task = asyncio.create_task(_run_auto_approve(session_id, user_id, baseline_index))
     _pending_auto_approvals[session_id] = task
-    task.add_done_callback(lambda t: _pending_auto_approvals.pop(session_id, None))
+    # Only remove from dict if this task is still the current one — a
+    # cancelled old task's callback must not clobber a newly-scheduled one.
+    task.add_done_callback(
+        lambda t: (
+            _pending_auto_approvals.pop(session_id, None)
+            if _pending_auto_approvals.get(session_id) is t
+            else None
+        )
+    )
 
 
 class DecomposeGoalTool(BaseTool):

From 225bdfb5437d8412bee3a7988db44316e0908fe8 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 17:53:53 +0000
Subject: [PATCH 34/61] test(frontend): add integration tests for
 DecomposeGoal, StepItem, and ChatMessagesContainer helpers

Agent-Logs-Url: https://github.com/Significant-Gravitas/AutoGPT/sessions/fbc0ab75-9d2e-4ea5-b9c7-c53fb8605913

Co-authored-by: ntindle <8845353+ntindle@users.noreply.github.com>
---
 .../__tests__/helpers.test.ts                 | 316 ++++++++++++++
 .../__tests__/DecomposeGoal.test.tsx          | 400 ++++++++++++++++++
 .../components/__tests__/StepItem.test.tsx    |  61 +++
 3 files changed, 777 insertions(+)
 create mode 100644 autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
 create mode 100644 autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
 create mode 100644 autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/__tests__/StepItem.test.tsx

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
new file mode 100644
index 000000000000..ebae176525f6
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -0,0 +1,316 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildRenderSegments,
+  isCompletedToolPart,
+  isInteractiveToolPart,
+  parseSpecialMarkers,
+  splitReasoningAndResponse,
+} from "../helpers";
+import type { MessagePart, RenderSegment } from "../helpers";
+
+function textPart(text: string): MessagePart {
+  return { type: "text", text } as MessagePart;
+}
+
+function toolPart(
+  toolName: string,
+  state: string,
+  output?: unknown,
+): MessagePart {
+  return {
+    type: `tool-${toolName}`,
+    toolCallId: `call_${toolName}`,
+    toolName,
+    state,
+    output,
+  } as unknown as MessagePart;
+}
+
+describe("isCompletedToolPart", () => {
+  it("returns true for output-available tool part", () => {
+    const part = toolPart("some_tool", "output-available");
+    expect(isCompletedToolPart(part)).toBe(true);
+  });
+
+  it("returns true for output-error tool part", () => {
+    const part = toolPart("some_tool", "output-error");
+    expect(isCompletedToolPart(part)).toBe(true);
+  });
+
+  it("returns false for input-streaming tool part", () => {
+    const part = toolPart("some_tool", "input-streaming");
+    expect(isCompletedToolPart(part)).toBe(false);
+  });
+
+  it("returns false for text part", () => {
+    const part = textPart("hello");
+    expect(isCompletedToolPart(part)).toBe(false);
+  });
+});
+
+describe("isInteractiveToolPart", () => {
+  it("returns true for task_decomposition type", () => {
+    const part = toolPart("decompose_goal", "output-available", {
+      type: "task_decomposition",
+      message: "Plan",
+      goal: "Build agent",
+      steps: [],
+      step_count: 0,
+      requires_approval: true,
+    });
+    expect(isInteractiveToolPart(part)).toBe(true);
+  });
+
+  it("returns true for setup_requirements type", () => {
+    const part = toolPart("run_mcp_tool", "output-available", {
+      type: "setup_requirements",
+      message: "Setup needed",
+    });
+    expect(isInteractiveToolPart(part)).toBe(true);
+  });
+
+  it("returns true for agent_details type", () => {
+    const part = toolPart("find_agent", "output-available", {
+      type: "agent_details",
+    });
+    expect(isInteractiveToolPart(part)).toBe(true);
+  });
+
+  it("returns false for non-interactive output type", () => {
+    const part = toolPart("some_tool", "output-available", {
+      type: "generic_output",
+    });
+    expect(isInteractiveToolPart(part)).toBe(false);
+  });
+
+  it("returns false when state is not output-available", () => {
+    const part = toolPart("decompose_goal", "input-streaming", {
+      type: "task_decomposition",
+    });
+    expect(isInteractiveToolPart(part)).toBe(false);
+  });
+
+  it("returns false for non-tool parts", () => {
+    const part = textPart("hello");
+    expect(isInteractiveToolPart(part)).toBe(false);
+  });
+
+  it("returns false when output is null", () => {
+    const part = toolPart("decompose_goal", "output-available", null);
+    expect(isInteractiveToolPart(part)).toBe(false);
+  });
+
+  it("handles JSON-encoded string output", () => {
+    const part = toolPart(
+      "decompose_goal",
+      "output-available",
+      JSON.stringify({ type: "task_decomposition" }),
+    );
+    expect(isInteractiveToolPart(part)).toBe(true);
+  });
+
+  it("returns false for invalid JSON string output", () => {
+    const part = toolPart(
+      "decompose_goal",
+      "output-available",
+      "not valid json",
+    );
+    expect(isInteractiveToolPart(part)).toBe(false);
+  });
+});
+
+describe("buildRenderSegments", () => {
+  it("returns individual segments for custom tool types", () => {
+    const parts = [
+      toolPart("decompose_goal", "output-available", {
+        type: "task_decomposition",
+      }),
+    ];
+    const segments = buildRenderSegments(parts);
+    expect(segments).toHaveLength(1);
+    expect(segments[0].kind).toBe("part");
+  });
+
+  it("collapses consecutive generic completed tool parts", () => {
+    const parts = [
+      toolPart("unknown_tool_a", "output-available"),
+      toolPart("unknown_tool_b", "output-available"),
+    ];
+    const segments = buildRenderSegments(parts);
+    expect(segments).toHaveLength(1);
+    expect(segments[0].kind).toBe("collapsed-group");
+    if (segments[0].kind === "collapsed-group") {
+      expect(segments[0].parts).toHaveLength(2);
+    }
+  });
+
+  it("does not collapse custom tool types into groups", () => {
+    const parts = [
+      toolPart("decompose_goal", "output-available", {
+        type: "task_decomposition",
+      }),
+      toolPart("create_agent", "output-available"),
+    ];
+    const segments = buildRenderSegments(parts);
+    expect(segments).toHaveLength(2);
+    expect(segments[0].kind).toBe("part");
+    expect(segments[1].kind).toBe("part");
+  });
+
+  it("renders text parts individually", () => {
+    const parts = [textPart("Hello"), textPart("World")];
+    const segments = buildRenderSegments(parts);
+    expect(segments).toHaveLength(2);
+    expect(segments.every((s) => s.kind === "part")).toBe(true);
+  });
+
+  it("handles mixed custom tools, generic tools, and text", () => {
+    const parts = [
+      textPart("Plan:"),
+      toolPart("decompose_goal", "output-available"),
+      toolPart("generic_a", "output-available"),
+      toolPart("generic_b", "output-available"),
+      textPart("Done"),
+    ];
+    const segments = buildRenderSegments(parts);
+
+    expect(segments[0].kind).toBe("part");
+    expect(segments[1].kind).toBe("part");
+    expect(segments[2].kind).toBe("collapsed-group");
+    expect(segments[3].kind).toBe("part");
+  });
+
+  it("does not collapse a single generic tool part", () => {
+    const parts = [
+      toolPart("generic_a", "output-available"),
+    ];
+    const segments = buildRenderSegments(parts);
+    expect(segments).toHaveLength(1);
+    expect(segments[0].kind).toBe("part");
+  });
+
+  it("preserves baseIndex offset in part segments", () => {
+    const parts = [textPart("Hello")];
+    const segments = buildRenderSegments(parts, 5);
+    expect(segments).toHaveLength(1);
+    if (segments[0].kind === "part") {
+      expect(segments[0].index).toBe(5);
+    }
+  });
+});
+
+describe("splitReasoningAndResponse", () => {
+  it("returns all parts as response when no tools are present", () => {
+    const parts = [textPart("Hello"), textPart("World")];
+    const { reasoning, response } = splitReasoningAndResponse(parts);
+    expect(reasoning).toHaveLength(0);
+    expect(response).toHaveLength(2);
+  });
+
+  it("returns all parts as response when no text follows the last tool", () => {
+    const parts = [
+      textPart("Thinking..."),
+      toolPart("decompose_goal", "output-available", {
+        type: "task_decomposition",
+      }),
+    ];
+    const { reasoning, response } = splitReasoningAndResponse(parts);
+    expect(reasoning).toHaveLength(0);
+    expect(response).toHaveLength(2);
+  });
+
+  it("splits reasoning and response when text follows the last tool", () => {
+    const parts = [
+      textPart("Let me plan this..."),
+      toolPart("decompose_goal", "output-available", {
+        type: "task_decomposition",
+      }),
+      textPart("Here is the plan."),
+    ];
+    const { reasoning, response } = splitReasoningAndResponse(parts);
+    expect(reasoning).toHaveLength(1);
+    expect(response).toHaveLength(2);
+  });
+
+  it("pins interactive tool parts to response section", () => {
+    const interactiveTool = toolPart(
+      "decompose_goal",
+      "output-available",
+      { type: "task_decomposition" },
+    );
+    const parts = [
+      textPart("Thinking..."),
+      interactiveTool,
+      textPart("Here is the summary."),
+    ];
+    const { reasoning, response } = splitReasoningAndResponse(parts);
+
+    expect(reasoning).toHaveLength(1);
+    expect(reasoning[0]).toBe(parts[0]);
+
+    expect(response).toHaveLength(2);
+    expect(response[0]).toBe(interactiveTool);
+    expect(response[1]).toBe(parts[2]);
+  });
+
+  it("keeps non-interactive tool parts in reasoning", () => {
+    const genericTool = toolPart("find_block", "output-available", {
+      type: "block_list",
+    });
+    const parts = [
+      textPart("Looking for blocks..."),
+      genericTool,
+      textPart("Found them."),
+    ];
+    const { reasoning, response } = splitReasoningAndResponse(parts);
+    expect(reasoning).toHaveLength(2);
+    expect(reasoning[1]).toBe(genericTool);
+    expect(response).toHaveLength(1);
+  });
+});
+
+describe("parseSpecialMarkers", () => {
+  it("returns null marker for plain text", () => {
+    const result = parseSpecialMarkers("Hello world");
+    expect(result.markerType).toBeNull();
+    expect(result.cleanText).toBe("Hello world");
+  });
+
+  it("detects error marker", () => {
+    const result = parseSpecialMarkers(
+      "Some preamble [__COPILOT_ERROR_f7a1__] Something went wrong",
+    );
+    expect(result.markerType).toBe("error");
+    expect(result.markerText).toBe("Something went wrong");
+  });
+
+  it("detects retryable error marker", () => {
+    const result = parseSpecialMarkers(
+      "[__COPILOT_RETRYABLE_ERROR_a9c2__] Timeout reached",
+    );
+    expect(result.markerType).toBe("retryable_error");
+    expect(result.markerText).toBe("Timeout reached");
+  });
+
+  it("detects system marker", () => {
+    const result = parseSpecialMarkers(
+      "[__COPILOT_SYSTEM_e3b0__] Session expired",
+    );
+    expect(result.markerType).toBe("system");
+    expect(result.markerText).toBe("Session expired");
+  });
+
+  it("retryable takes precedence over regular error when both present", () => {
+    const text =
+      "[__COPILOT_RETRYABLE_ERROR_a9c2__] Retryable issue [__COPILOT_ERROR_f7a1__] Also error";
+    const result = parseSpecialMarkers(text);
+    expect(result.markerType).toBe("retryable_error");
+  });
+
+  it("strips marker from cleanText", () => {
+    const result = parseSpecialMarkers(
+      "Preamble text [__COPILOT_SYSTEM_e3b0__] System message",
+    );
+    expect(result.cleanText).toBe("Preamble text");
+  });
+});
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
new file mode 100644
index 000000000000..2661df66d7e9
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
@@ -0,0 +1,400 @@
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+} from "@/tests/integrations/test-utils";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DecomposeGoalTool } from "../DecomposeGoal";
+import type { TaskDecompositionOutput } from "../helpers";
+
+const mockOnSend = vi.fn();
+vi.mock(
+  "../../../components/CopilotChatActionsProvider/useCopilotChatActions",
+  () => ({
+    useCopilotChatActions: () => ({ onSend: mockOnSend }),
+  }),
+);
+
+vi.mock("@/app/api/__generated__/endpoints/chat/chat", () => ({
+  postV2CancelAutoApproveTask: vi.fn(() => Promise.resolve()),
+}));
+
+const STEPS = [
+  {
+    step_id: "step_1",
+    description: "Add input block",
+    action: "add_input",
+    block_name: null,
+    status: "pending",
+  },
+  {
+    step_id: "step_2",
+    description: "Add AI summarizer",
+    action: "add_block",
+    block_name: "AI Text Generator",
+    status: "pending",
+  },
+  {
+    step_id: "step_3",
+    description: "Connect blocks",
+    action: "connect_blocks",
+    block_name: null,
+    status: "pending",
+  },
+];
+
+const DECOMPOSITION: TaskDecompositionOutput = {
+  type: "task_decomposition",
+  message: "Here's the plan (3 steps):",
+  goal: "Build a news summarizer",
+  steps: STEPS,
+  step_count: 3,
+  requires_approval: true,
+  auto_approve_seconds: 60,
+  created_at: new Date().toISOString(),
+  session_id: "test-session-1",
+};
+
+function makePart(
+  state: string,
+  output?: unknown,
+): { type: string; toolCallId: string; toolName: string; state: string; input?: unknown; output?: unknown } {
+  return {
+    type: "tool-decompose_goal",
+    toolCallId: "call_1",
+    toolName: "decompose_goal",
+    state,
+    output,
+  };
+}
+
+describe("DecomposeGoalTool", () => {
+  afterEach(() => {
+    cleanup();
+    mockOnSend.mockClear();
+  });
+
+  it("renders analyzing animation during input-streaming", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("input-streaming") as any}
+        isLastMessage
+      />,
+    );
+    expect(screen.getByText(/A/)).toBeDefined();
+  });
+
+  it("renders error card when state is output-error", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-error") as any}
+        isLastMessage
+      />,
+    );
+    expect(
+      screen.getByText(/Failed to analyze the goal/i),
+    ).toBeDefined();
+    expect(screen.getByText("Try again")).toBeDefined();
+  });
+
+  it("sends retry message when Try again is clicked on error", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-error") as any}
+        isLastMessage
+      />,
+    );
+    fireEvent.click(screen.getByText("Try again"));
+    expect(mockOnSend).toHaveBeenCalledWith(
+      "Please try decomposing the goal again.",
+    );
+  });
+
+  it("renders error card for error output object", () => {
+    const errorOutput = {
+      type: "error",
+      error: "missing_steps",
+      message: "Please provide at least one step.",
+    };
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", errorOutput) as any}
+        isLastMessage
+      />,
+    );
+    expect(
+      screen.getByText("Please provide at least one step."),
+    ).toBeDefined();
+  });
+
+  it("renders the build plan accordion with steps", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+    expect(screen.getByText(/Build Plan — 3 steps/)).toBeDefined();
+    expect(screen.getByText("Build a news summarizer")).toBeDefined();
+    expect(screen.getByText(/Here's the plan/)).toBeDefined();
+    expect(screen.getByText(/1\. Add input block/)).toBeDefined();
+    expect(screen.getByText(/2\. Add AI summarizer/)).toBeDefined();
+    expect(screen.getByText(/3\. Connect blocks/)).toBeDefined();
+  });
+
+  it("renders block name badges for steps that have them", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+    expect(screen.getByText("AI Text Generator")).toBeDefined();
+  });
+
+  it("shows approve and modify buttons when requires_approval and isLastMessage", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+    expect(screen.getByText("Modify")).toBeDefined();
+    expect(screen.getByText(/Starting in/)).toBeDefined();
+  });
+
+  it("hides action buttons when isLastMessage is false", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage={false}
+      />,
+    );
+    expect(screen.queryByText("Modify")).toBeNull();
+    expect(
+      screen.getByText(/Review the plan above and approve/),
+    ).toBeDefined();
+  });
+
+  it("hides action buttons when requires_approval is false", () => {
+    const noApproval = { ...DECOMPOSITION, requires_approval: false };
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", noApproval) as any}
+        isLastMessage
+      />,
+    );
+    expect(screen.queryByText("Modify")).toBeNull();
+  });
+
+  it("disables buttons while message is still streaming", () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+        isMessageStreaming
+      />,
+    );
+    const modifyBtn = screen.getByText("Modify").closest("button");
+    expect(modifyBtn?.disabled).toBe(true);
+  });
+
+  it("sends approval message when approve button is clicked", async () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    const startBtn = screen.getByText(/Starting in/).closest("button");
+    expect(startBtn).toBeDefined();
+    fireEvent.click(startBtn!);
+
+    await waitFor(() => {
+      expect(mockOnSend).toHaveBeenCalledWith(
+        "Approved. Please build the agent.",
+      );
+    });
+  });
+
+  it("does not send duplicate approval on second click", async () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    const startBtn = screen.getByText(/Starting in/).closest("button");
+    fireEvent.click(startBtn!);
+    fireEvent.click(startBtn!);
+
+    await waitFor(() => {
+      expect(mockOnSend).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it("enters edit mode when Modify is clicked", async () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    fireEvent.click(screen.getByText("Modify"));
+
+    await waitFor(() => {
+      const textareas = screen.getAllByPlaceholderText("Step description");
+      expect(textareas.length).toBe(3);
+    });
+  });
+
+  it("cancels auto-approve on the server when Modify is clicked", async () => {
+    const { postV2CancelAutoApproveTask } = await import(
+      "@/app/api/__generated__/endpoints/chat/chat"
+    );
+
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    fireEvent.click(screen.getByText("Modify"));
+
+    await waitFor(() => {
+      expect(postV2CancelAutoApproveTask).toHaveBeenCalledWith(
+        "test-session-1",
+      );
+    });
+  });
+
+  it("allows editing step descriptions in edit mode", async () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    fireEvent.click(screen.getByText("Modify"));
+
+    await waitFor(() => {
+      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
+    });
+
+    const textareas = screen.getAllByPlaceholderText("Step description");
+    fireEvent.change(textareas[0], {
+      target: { value: "Fetch RSS feed" },
+    });
+
+    expect(
+      (screen.getAllByPlaceholderText("Step description")[0] as HTMLTextAreaElement).value,
+    ).toBe("Fetch RSS feed");
+  });
+
+  it("allows deleting steps in edit mode", async () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    fireEvent.click(screen.getByText("Modify"));
+
+    await waitFor(() => {
+      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
+    });
+
+    const removeButtons = screen.getAllByLabelText("Remove step");
+    fireEvent.click(removeButtons[0]);
+
+    await waitFor(() => {
+      expect(screen.getAllByPlaceholderText("Step description").length).toBe(2);
+    });
+  });
+
+  it("allows inserting new steps in edit mode", async () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    fireEvent.click(screen.getByText("Modify"));
+
+    await waitFor(() => {
+      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
+    });
+
+    const insertButtons = screen.getAllByLabelText("Insert step here");
+    fireEvent.click(insertButtons[0]);
+
+    await waitFor(() => {
+      expect(screen.getAllByPlaceholderText("Step description").length).toBe(4);
+    });
+  });
+
+  it("sends modified steps message when approve is clicked in edit mode", async () => {
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    fireEvent.click(screen.getByText("Modify"));
+
+    await waitFor(() => {
+      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
+    });
+
+    const textareas = screen.getAllByPlaceholderText("Step description");
+    fireEvent.change(textareas[0], {
+      target: { value: "Fetch RSS feed" },
+    });
+
+    fireEvent.click(screen.getByText("Approve"));
+
+    await waitFor(() => {
+      expect(mockOnSend).toHaveBeenCalledWith(
+        expect.stringContaining("Approved with modifications"),
+      );
+      expect(mockOnSend).toHaveBeenCalledWith(
+        expect.stringContaining("Fetch RSS feed"),
+      );
+    });
+  });
+
+  it("renders countdown timer in the approve button", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(DECOMPOSITION.created_at!));
+
+    render(
+      <DecomposeGoalTool
+        part={makePart("output-available", DECOMPOSITION) as any}
+        isLastMessage
+      />,
+    );
+
+    expect(screen.getByText("60")).toBeDefined();
+    vi.useRealTimers();
+  });
+
+  it("renders nothing pending when output is not yet available", () => {
+    const { container } = render(
+      <DecomposeGoalTool
+        part={makePart("input-available") as any}
+        isLastMessage
+      />,
+    );
+    expect(container.querySelector(".py-2")).toBeDefined();
+  });
+});
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/__tests__/StepItem.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/__tests__/StepItem.test.tsx
new file mode 100644
index 000000000000..fc59b3311c42
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/components/__tests__/StepItem.test.tsx
@@ -0,0 +1,61 @@
+import { render, screen } from "@/tests/integrations/test-utils";
+import { describe, expect, it } from "vitest";
+import { StepItem } from "../StepItem";
+
+describe("StepItem", () => {
+  it("renders step number and description", () => {
+    render(
+      <StepItem index={0} description="Add input block" status="pending" />,
+    );
+    expect(screen.getByText("1. Add input block")).toBeDefined();
+  });
+
+  it("renders block name when provided", () => {
+    render(
+      <StepItem
+        index={1}
+        description="Add AI summarizer"
+        blockName="AI Text Generator"
+        status="pending"
+      />,
+    );
+    expect(screen.getByText("AI Text Generator")).toBeDefined();
+  });
+
+  it("does not render block name when null", () => {
+    render(
+      <StepItem
+        index={0}
+        description="Connect blocks"
+        blockName={null}
+        status="pending"
+      />,
+    );
+    expect(screen.queryByText("AI Text Generator")).toBeNull();
+  });
+
+  it("renders pending icon by default", () => {
+    render(<StepItem index={0} description="Step" status="pending" />);
+    expect(screen.getByLabelText("pending")).toBeDefined();
+  });
+
+  it("renders completed icon for completed status", () => {
+    render(<StepItem index={0} description="Step" status="completed" />);
+    expect(screen.getByLabelText("completed")).toBeDefined();
+  });
+
+  it("renders in-progress icon for in_progress status", () => {
+    render(<StepItem index={0} description="Step" status="in_progress" />);
+    expect(screen.getByLabelText("in progress")).toBeDefined();
+  });
+
+  it("renders failed icon for failed status", () => {
+    render(<StepItem index={0} description="Step" status="failed" />);
+    expect(screen.getByLabelText("failed")).toBeDefined();
+  });
+
+  it("uses zero-based index to render 1-based step number", () => {
+    render(<StepItem index={4} description="Fifth step" status="pending" />);
+    expect(screen.getByText("5. Fifth step")).toBeDefined();
+  });
+});

From 420251ca9dade96c3128e56b63a7a0dc53d7c8b6 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 15 Apr 2026 20:19:03 +0200
Subject: [PATCH 35/61] fix(copilot): clean up stream registry on enqueue
 failure in auto-approve
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

If enqueue_copilot_turn failed after stream_registry.create_session, the
session was left in "running" state in Redis — locking the session until
the TTL expired. Now calls mark_session_completed on failure so the
session is released immediately.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py   | 22 +++++++++++++------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index d9c6e5b265f7..d6ed20df12d9 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -119,13 +119,21 @@ async def _run_auto_approve(
             tool_name="chat",
             turn_id=turn_id,
         )
-        await enqueue_copilot_turn(
-            session_id=session_id,
-            user_id=user_id,
-            message=AUTO_APPROVE_MESSAGE,
-            turn_id=turn_id,
-            is_user_message=True,
-        )
+        try:
+            await enqueue_copilot_turn(
+                session_id=session_id,
+                user_id=user_id,
+                message=AUTO_APPROVE_MESSAGE,
+                turn_id=turn_id,
+                is_user_message=True,
+            )
+        except Exception:
+            # If enqueueing fails, mark the session completed so it doesn't
+            # stay stuck in "running" state in the stream registry forever.
+            await stream_registry.mark_session_completed(
+                session_id, error_message="Auto-approve enqueue failed"
+            )
+            raise
         logger.info("decompose_goal auto-approve fired for session %s", session_id)
     except asyncio.CancelledError:
         raise

From 559438fd649d761d462ef5557aee29adec8a7108 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 20:16:28 +0000
Subject: [PATCH 36/61] fix(frontend): run pnpm format on DecomposeGoal test
 files

Agent-Logs-Url: https://github.com/Significant-Gravitas/AutoGPT/sessions/40326921-8824-4f62-bb6b-9f7dc5f89657

Co-authored-by: ntindle <8845353+ntindle@users.noreply.github.com>
---
 .../__tests__/helpers.test.ts                 | 12 +++------
 .../__tests__/DecomposeGoal.test.tsx          | 27 +++++++++++--------
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index ebae176525f6..77b2529f4ded 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -181,9 +181,7 @@ describe("buildRenderSegments", () => {
   });
 
   it("does not collapse a single generic tool part", () => {
-    const parts = [
-      toolPart("generic_a", "output-available"),
-    ];
+    const parts = [toolPart("generic_a", "output-available")];
     const segments = buildRenderSegments(parts);
     expect(segments).toHaveLength(1);
     expect(segments[0].kind).toBe("part");
@@ -233,11 +231,9 @@ describe("splitReasoningAndResponse", () => {
   });
 
   it("pins interactive tool parts to response section", () => {
-    const interactiveTool = toolPart(
-      "decompose_goal",
-      "output-available",
-      { type: "task_decomposition" },
-    );
+    const interactiveTool = toolPart("decompose_goal", "output-available", {
+      type: "task_decomposition",
+    });
     const parts = [
       textPart("Thinking..."),
       interactiveTool,
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
index 2661df66d7e9..e0fbd852d0a5 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
@@ -60,7 +60,14 @@ const DECOMPOSITION: TaskDecompositionOutput = {
 function makePart(
   state: string,
   output?: unknown,
-): { type: string; toolCallId: string; toolName: string; state: string; input?: unknown; output?: unknown } {
+): {
+  type: string;
+  toolCallId: string;
+  toolName: string;
+  state: string;
+  input?: unknown;
+  output?: unknown;
+} {
   return {
     type: "tool-decompose_goal",
     toolCallId: "call_1",
@@ -93,9 +100,7 @@ describe("DecomposeGoalTool", () => {
         isLastMessage
       />,
     );
-    expect(
-      screen.getByText(/Failed to analyze the goal/i),
-    ).toBeDefined();
+    expect(screen.getByText(/Failed to analyze the goal/i)).toBeDefined();
     expect(screen.getByText("Try again")).toBeDefined();
   });
 
@@ -124,9 +129,7 @@ describe("DecomposeGoalTool", () => {
         isLastMessage
       />,
     );
-    expect(
-      screen.getByText("Please provide at least one step."),
-    ).toBeDefined();
+    expect(screen.getByText("Please provide at least one step.")).toBeDefined();
   });
 
   it("renders the build plan accordion with steps", () => {
@@ -173,9 +176,7 @@ describe("DecomposeGoalTool", () => {
       />,
     );
     expect(screen.queryByText("Modify")).toBeNull();
-    expect(
-      screen.getByText(/Review the plan above and approve/),
-    ).toBeDefined();
+    expect(screen.getByText(/Review the plan above and approve/)).toBeDefined();
   });
 
   it("hides action buttons when requires_approval is false", () => {
@@ -294,7 +295,11 @@ describe("DecomposeGoalTool", () => {
     });
 
     expect(
-      (screen.getAllByPlaceholderText("Step description")[0] as HTMLTextAreaElement).value,
+      (
+        screen.getAllByPlaceholderText(
+          "Step description",
+        )[0] as HTMLTextAreaElement
+      ).value,
     ).toBe("Fetch RSS feed");
   });
 

From e4a3c4f6ce1fe2209e0b58f11836b02aff76fb47 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 16 Apr 2026 00:50:50 +0200
Subject: [PATCH 37/61] style(copilot): reformat test files

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../__tests__/helpers.test.ts                 | 12 +++------
 .../__tests__/DecomposeGoal.test.tsx          | 27 +++++++++++--------
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index ebae176525f6..77b2529f4ded 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -181,9 +181,7 @@ describe("buildRenderSegments", () => {
   });
 
   it("does not collapse a single generic tool part", () => {
-    const parts = [
-      toolPart("generic_a", "output-available"),
-    ];
+    const parts = [toolPart("generic_a", "output-available")];
     const segments = buildRenderSegments(parts);
     expect(segments).toHaveLength(1);
     expect(segments[0].kind).toBe("part");
@@ -233,11 +231,9 @@ describe("splitReasoningAndResponse", () => {
   });
 
   it("pins interactive tool parts to response section", () => {
-    const interactiveTool = toolPart(
-      "decompose_goal",
-      "output-available",
-      { type: "task_decomposition" },
-    );
+    const interactiveTool = toolPart("decompose_goal", "output-available", {
+      type: "task_decomposition",
+    });
     const parts = [
       textPart("Thinking..."),
       interactiveTool,
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
index 2661df66d7e9..e0fbd852d0a5 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
@@ -60,7 +60,14 @@ const DECOMPOSITION: TaskDecompositionOutput = {
 function makePart(
   state: string,
   output?: unknown,
-): { type: string; toolCallId: string; toolName: string; state: string; input?: unknown; output?: unknown } {
+): {
+  type: string;
+  toolCallId: string;
+  toolName: string;
+  state: string;
+  input?: unknown;
+  output?: unknown;
+} {
   return {
     type: "tool-decompose_goal",
     toolCallId: "call_1",
@@ -93,9 +100,7 @@ describe("DecomposeGoalTool", () => {
         isLastMessage
       />,
     );
-    expect(
-      screen.getByText(/Failed to analyze the goal/i),
-    ).toBeDefined();
+    expect(screen.getByText(/Failed to analyze the goal/i)).toBeDefined();
     expect(screen.getByText("Try again")).toBeDefined();
   });
 
@@ -124,9 +129,7 @@ describe("DecomposeGoalTool", () => {
         isLastMessage
       />,
     );
-    expect(
-      screen.getByText("Please provide at least one step."),
-    ).toBeDefined();
+    expect(screen.getByText("Please provide at least one step.")).toBeDefined();
   });
 
   it("renders the build plan accordion with steps", () => {
@@ -173,9 +176,7 @@ describe("DecomposeGoalTool", () => {
       />,
     );
     expect(screen.queryByText("Modify")).toBeNull();
-    expect(
-      screen.getByText(/Review the plan above and approve/),
-    ).toBeDefined();
+    expect(screen.getByText(/Review the plan above and approve/)).toBeDefined();
   });
 
   it("hides action buttons when requires_approval is false", () => {
@@ -294,7 +295,11 @@ describe("DecomposeGoalTool", () => {
     });
 
     expect(
-      (screen.getAllByPlaceholderText("Step description")[0] as HTMLTextAreaElement).value,
+      (
+        screen.getAllByPlaceholderText(
+          "Step description",
+        )[0] as HTMLTextAreaElement
+      ).value,
     ).toBe("Fetch RSS feed");
   });
 

From 480ec7021854d6d33bc63c9f5d8289908de43b92 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Thu, 16 Apr 2026 01:53:42 +0200
Subject: [PATCH 38/61] fix(frontend): remove unused RenderSegment type import

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../components/ChatMessagesContainer/__tests__/helpers.test.ts  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index 77b2529f4ded..552b83f198f2 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -6,7 +6,7 @@ import {
   parseSpecialMarkers,
   splitReasoningAndResponse,
 } from "../helpers";
-import type { MessagePart, RenderSegment } from "../helpers";
+import type { MessagePart } from "../helpers";
 
 function textPart(text: string): MessagePart {
   return { type: "text", text } as MessagePart;

From 4d5969d59e4583083bfefa2fbf0c6364f0a2195e Mon Sep 17 00:00:00 2001
From: Zamil Majdy <zamil.majdy@agpt.co>
Date: Fri, 17 Apr 2026 18:12:27 +0700
Subject: [PATCH 39/61] refactor(copilot): simplify cancel-auto-approve route,
 derive countdown from timestamp

- Route always returns cancelled=True, reason branch was dead code since
  cancel_auto_approve() unconditionally returns True
- Use crypto.randomUUID() for new step IDs to avoid same-millisecond collisions
  on rapid insert clicks
- Re-derive secondsLeft from created_at+auto_approve_seconds on each tick
  (and on visibilitychange) instead of naive decrement; browsers throttle
  setInterval in background tabs, causing the displayed countdown to drift
  far behind wall-clock time
---
 .../backend/api/features/chat/routes.py       |  7 +---
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 39 +++++++++++++++----
 2 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/autogpt_platform/backend/backend/api/features/chat/routes.py b/autogpt_platform/backend/backend/api/features/chat/routes.py
index 3baa4b6b5c2c..4daf08b18544 100644
--- a/autogpt_platform/backend/backend/api/features/chat/routes.py
+++ b/autogpt_platform/backend/backend/api/features/chat/routes.py
@@ -861,11 +861,8 @@ async def cancel_auto_approve_task(
 
     from backend.copilot.tools.decompose_goal import cancel_auto_approve
 
-    cancelled = await cancel_auto_approve(session_id)
-    return CancelSessionResponse(
-        cancelled=cancelled,
-        reason=None if cancelled else "no_pending_auto_approve",
-    )
+    await cancel_auto_approve(session_id)
+    return CancelSessionResponse(cancelled=True)
 
 
 @router.post(
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index fdf3328ca1f7..8175681f44c3 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -170,7 +170,7 @@ export function DecomposeGoalTool({
     setEditableSteps((prev) => {
       const next = [...prev];
       next.splice(afterIndex + 1, 0, {
-        step_id: `step_new_${Date.now()}`,
+        step_id: `step_new_${crypto.randomUUID()}`,
         description: "",
         action: "add_block",
         status: "pending",
@@ -186,14 +186,39 @@ export function DecomposeGoalTool({
     }
   }, [showActions, isEditing]);
 
-  // Tick down only while the timer is active.
+  // Re-derive remaining seconds from ``created_at`` on every tick (and on
+  // tab visibility change) instead of decrementing a local counter.
+  // ``setInterval`` is aggressively throttled in backgrounded tabs, so a
+  // naive ``s - 1`` drifts behind wall-clock time — the user could reopen
+  // the tab well past the deadline and still see e.g. "Starting in 45".
+  // Re-deriving keeps the UI in sync with the server-side timer.
+  const createdAt =
+    output && isDecompositionOutput(output) ? output.created_at : undefined;
   useEffect(() => {
     if (!showActions || !timerActive) return;
-    const interval = setInterval(() => {
-      setSecondsLeft((s) => Math.max(0, s - 1));
-    }, 1000);
-    return () => clearInterval(interval);
-  }, [showActions, timerActive, part.toolCallId]);
+    const deadlineMs = createdAt
+      ? new Date(createdAt).getTime() + countdownSeconds * 1000
+      : null;
+    function recompute() {
+      if (deadlineMs !== null && !Number.isNaN(deadlineMs)) {
+        const remaining = Math.max(
+          0,
+          Math.round((deadlineMs - Date.now()) / 1000),
+        );
+        setSecondsLeft(Math.min(countdownSeconds, remaining));
+      } else {
+        // Legacy session with no ``created_at`` — fall back to naive decrement.
+        setSecondsLeft((s) => Math.max(0, s - 1));
+      }
+    }
+    recompute();
+    const interval = setInterval(recompute, 1000);
+    document.addEventListener("visibilitychange", recompute);
+    return () => {
+      clearInterval(interval);
+      document.removeEventListener("visibilitychange", recompute);
+    };
+  }, [showActions, timerActive, part.toolCallId, createdAt, countdownSeconds]);
 
   // Auto-approve when countdown reaches 0. The client fires at 60s; the
   // server fires 5s later as a fallback for the "user closed the tab" case.

From a31297cf8abd8c6fc1e46160e1837477c3d534a8 Mon Sep 17 00:00:00 2001
From: Zamil Majdy <zamil.majdy@agpt.co>
Date: Fri, 17 Apr 2026 18:34:14 +0700
Subject: [PATCH 40/61] fix(frontend): avoid eager decrement on legacy
 decompose_goal sessions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Guard the synchronous recompute() call so only deadline-driven (has
created_at) sessions correct stale state on mount. Legacy fallback now
waits the first 1s tick instead of snapping 60→59 instantly.
---
 .../copilot/tools/DecomposeGoal/DecomposeGoal.tsx         | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 8175681f44c3..d60e5a394d22 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -199,8 +199,9 @@ export function DecomposeGoalTool({
     const deadlineMs = createdAt
       ? new Date(createdAt).getTime() + countdownSeconds * 1000
       : null;
+    const hasDeadline = deadlineMs !== null && !Number.isNaN(deadlineMs);
     function recompute() {
-      if (deadlineMs !== null && !Number.isNaN(deadlineMs)) {
+      if (hasDeadline) {
         const remaining = Math.max(
           0,
           Math.round((deadlineMs - Date.now()) / 1000),
@@ -211,7 +212,10 @@ export function DecomposeGoalTool({
         setSecondsLeft((s) => Math.max(0, s - 1));
       }
     }
-    recompute();
+    // Only correct stale state for deadline-driven sessions. The legacy
+    // fallback starts from the seeded ``secondsLeft`` and should not
+    // decrement before the first 1s tick elapses.
+    if (hasDeadline) recompute();
     const interval = setInterval(recompute, 1000);
     document.addEventListener("visibilitychange", recompute);
     return () => {

From 5b29ff5a16e4a62d048a1860e67307d773eb1d2e Mon Sep 17 00:00:00 2001
From: Zamil Majdy <zamil.majdy@agpt.co>
Date: Fri, 17 Apr 2026 18:44:37 +0700
Subject: [PATCH 41/61] fix(backend): invalidate cache on failed write in
 append_message_if

Mirror the failure-path invalidation already in append_and_save_message.
Without this, a failed cache write leaves stale session data in Redis,
which later predicate checks could act on and produce duplicate messages.
---
 autogpt_platform/backend/backend/copilot/model.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/autogpt_platform/backend/backend/copilot/model.py b/autogpt_platform/backend/backend/copilot/model.py
index 436630c90eaa..9b82682bcafe 100644
--- a/autogpt_platform/backend/backend/copilot/model.py
+++ b/autogpt_platform/backend/backend/copilot/model.py
@@ -757,6 +757,9 @@ async def append_message_if(
             await cache_chat_session(session)
         except Exception as e:
             logger.warning(f"Cache write failed for session {session_id}: {e}")
+            # Invalidate the stale entry so future reads fall back to DB,
+            # preventing a predicate check from acting on stale state.
+            await invalidate_session_cache(session_id)
 
         return session
 

From 982808c435e0bd4a2403b5c95c487e3733ceb7ee Mon Sep 17 00:00:00 2001
From: Zamil Majdy <zamil.majdy@agpt.co>
Date: Fri, 17 Apr 2026 18:49:08 +0700
Subject: [PATCH 42/61] fix(backend): skip append_message_if when session lock
 not acquired
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When Redis is unavailable, _get_session_lock yields False — without
this guard two concurrent callers could both read the same DB state,
both pass the predicate, and both append, producing duplicate messages.
append_message_if only powers non-critical fire-and-forget flows
(decompose_goal auto-approve), so skipping is safer than risking a
duplicate; the user can still trigger the action manually.
---
 .../backend/backend/copilot/model.py            | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/model.py b/autogpt_platform/backend/backend/copilot/model.py
index 9b82682bcafe..a9379cfb5b9f 100644
--- a/autogpt_platform/backend/backend/copilot/model.py
+++ b/autogpt_platform/backend/backend/copilot/model.py
@@ -726,9 +726,22 @@ async def append_message_if(
     the append are one atomic operation — no race with concurrent appends.
 
     Returns the updated session on append, or ``None`` if the predicate
-    rejected, the session no longer exists, or the append failed.
+    rejected, the session no longer exists, the lock could not be acquired,
+    or the append failed.
     """
-    async with _get_session_lock(session_id) as _lock_acquired:
+    async with _get_session_lock(session_id) as lock_acquired:
+        # Without the lock, concurrent callers could both read the same DB
+        # state, both pass the predicate, and both append — producing
+        # duplicate messages. Since ``append_message_if`` only powers
+        # non-critical fire-and-forget flows (e.g. decompose_goal
+        # auto-approve), skipping on lock failure is safer than risking a
+        # duplicate. The user can still trigger the action manually.
+        if not lock_acquired:
+            logger.warning(
+                "append_message_if: skipping for session %s (lock not acquired)",
+                session_id,
+            )
+            return None
         # Read from DB directly — the Redis cache can be stale because the
         # executor's upsert_chat_session overwrites it with in-memory copies
         # during streaming, which may not include messages appended by the

From 162c3f09a4ef5e24d7af5ca1fa30424ed5810d5f Mon Sep 17 00:00:00 2001
From: Zamil Majdy <zamil.majdy@agpt.co>
Date: Fri, 17 Apr 2026 20:03:58 +0700
Subject: [PATCH 43/61] fix(copilot): enforce decompose_goal approval gate at
 code level
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The 'STOP — do not proceed until the user approves' instruction in
agent_generation_guide.md was purely prompt-level. Observed failure:
the LLM called decompose_goal and create_agent in the same turn,
building the agent while the user was still mid-countdown — the whole
premise of the PR (user-approval before build) was being bypassed.

Add has_pending_decomposition(session) which checks session history
for an unanswered decompose_goal tool call, and call it from
create_agent._execute. When pending, the tool returns an ErrorResponse
instructing the LLM to end its turn instead of building.
---
 .../backend/copilot/tools/create_agent.py     | 20 +++++
 .../backend/copilot/tools/decompose_goal.py   | 30 ++++++++
 .../copilot/tools/decompose_goal_test.py      | 77 +++++++++++++++++++
 3 files changed, 127 insertions(+)

diff --git a/autogpt_platform/backend/backend/copilot/tools/create_agent.py b/autogpt_platform/backend/backend/copilot/tools/create_agent.py
index 7710cbafcad9..8ba85af41800 100644
--- a/autogpt_platform/backend/backend/copilot/tools/create_agent.py
+++ b/autogpt_platform/backend/backend/copilot/tools/create_agent.py
@@ -8,6 +8,7 @@
 
 from .agent_generator.pipeline import fetch_library_agents, fix_validate_and_save
 from .base import BaseTool
+from .decompose_goal import has_pending_decomposition
 from .models import ErrorResponse, ToolResponseBase
 
 logger = logging.getLogger(__name__)
@@ -70,6 +71,25 @@ async def _execute(
     ) -> ToolResponseBase:
         session_id = session.session_id if session else None
 
+        # Enforce the decompose_goal approval gate. The LLM is instructed via
+        # ``agent_generation_guide.md`` to STOP after decompose_goal until the
+        # user approves, but natural-language instructions alone are not
+        # reliable — without this gate, the LLM has been observed calling
+        # ``decompose_goal`` and ``create_agent`` in the same turn, building
+        # the agent while the user is still mid-countdown.
+        if session and has_pending_decomposition(session):
+            return ErrorResponse(
+                message=(
+                    "A build plan is awaiting user approval. Do not call "
+                    "create_agent until the user responds with Approved "
+                    "(or Approved with modifications). End your turn now — "
+                    "the platform will resume the conversation once the user "
+                    "responds."
+                ),
+                error="decomposition_pending_approval",
+                session_id=session_id,
+            )
+
         if not agent_json:
             return ErrorResponse(
                 message=(
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index d6ed20df12d9..9ee7cc50afcc 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -45,6 +45,36 @@
 _pending_auto_approvals: dict[str, asyncio.Task] = {}
 
 
+def has_pending_decomposition(session: ChatSession) -> bool:
+    """Return True if the most recent ``decompose_goal`` tool call in the
+    session has not yet been followed by a user message.
+
+    Used by build tools (create_agent, edit_agent, fix_agent_graph, …) to
+    enforce the "STOP — do not proceed until the user approves" gate from
+    ``agent_generation_guide.md`` at the *code* level. The natural-language
+    instruction alone is not enough — the LLM has been observed calling
+    ``decompose_goal`` and ``create_agent`` in the same turn, building the
+    agent while the user is still mid-countdown. This predicate lets build
+    tools refuse when approval is still pending.
+
+    Scans messages in reverse, returning:
+    - True  → a ``decompose_goal`` tool call exists with no user message after it
+    - False → no ``decompose_goal`` call, or the most recent one has already
+              been answered by a user message (Approve / Modify / other)
+    """
+    for i in range(len(session.messages) - 1, -1, -1):
+        msg = session.messages[i]
+        if msg.role == "user":
+            # A user message without a prior decompose_goal = nothing pending.
+            return False
+        if msg.role == "assistant" and msg.tool_calls:
+            for tc in msg.tool_calls:
+                name = (tc.get("function") or {}).get("name") or tc.get("name")
+                if name == "decompose_goal":
+                    return True
+    return False
+
+
 def _no_user_action_since(baseline_index: int):
     """Predicate: returns True iff no ``role == "user"`` message exists at
     or after ``baseline_index`` in the session message list.
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index 51d99d0434d7..c6900627f225 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -16,6 +16,7 @@
     DecomposeGoalTool,
     _no_user_action_since,
     cancel_auto_approve,
+    has_pending_decomposition,
 )
 from .models import ErrorResponse, TaskDecompositionResponse
 
@@ -345,6 +346,82 @@ def test_predicate_handles_messages_with_none_sequence():
     assert _no_user_action_since(2)(session) is False
 
 
+# ---------------------------------------------------------------------------
+# has_pending_decomposition — build-tool approval gate
+# ---------------------------------------------------------------------------
+
+
+def _decompose_tool_call() -> dict:
+    return {
+        "id": "call_1",
+        "type": "function",
+        "function": {"name": "decompose_goal", "arguments": "{}"},
+    }
+
+
+def test_pending_decomposition_true_when_no_user_after_call():
+    """LLM called decompose_goal but user hasn't responded yet."""
+    session = make_session(_USER_ID)
+    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
+    session.messages.append(
+        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
+    )
+    session.messages.append(ChatMessage(role="tool", content="{...plan...}"))
+    assert has_pending_decomposition(session) is True
+
+
+def test_pending_decomposition_false_after_user_approves():
+    """User approved — downstream tools should be unblocked."""
+    session = make_session(_USER_ID)
+    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
+    session.messages.append(
+        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
+    )
+    session.messages.append(ChatMessage(role="tool", content="{...plan...}"))
+    session.messages.append(
+        ChatMessage(role="user", content="Approved. Please build the agent.")
+    )
+    assert has_pending_decomposition(session) is False
+
+
+def test_pending_decomposition_false_when_no_decompose_call():
+    """Sessions without decompose_goal are never blocked."""
+    session = make_session(_USER_ID)
+    session.messages.append(ChatMessage(role="user", content="Change the prompt"))
+    session.messages.append(ChatMessage(role="assistant", content="Sure, will do."))
+    assert has_pending_decomposition(session) is False
+
+
+def test_pending_decomposition_ignores_assistant_text_without_tool_calls():
+    """Assistant's text after decompose_goal doesn't count as user action."""
+    session = make_session(_USER_ID)
+    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
+    session.messages.append(
+        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
+    )
+    session.messages.append(ChatMessage(role="tool", content="{...plan...}"))
+    session.messages.append(ChatMessage(role="assistant", content="Plan is ready."))
+    assert has_pending_decomposition(session) is True
+
+
+def test_pending_decomposition_scans_most_recent_call():
+    """Only the most recent decompose_goal matters; older ones are irrelevant."""
+    session = make_session(_USER_ID)
+    # Old cycle: decomposed, approved, built.
+    session.messages.append(ChatMessage(role="user", content="Build v1"))
+    session.messages.append(
+        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
+    )
+    session.messages.append(ChatMessage(role="tool", content="{plan v1}"))
+    session.messages.append(ChatMessage(role="user", content="Approved"))
+    # New cycle: decomposed, still awaiting approval.
+    session.messages.append(
+        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
+    )
+    session.messages.append(ChatMessage(role="tool", content="{plan v2}"))
+    assert has_pending_decomposition(session) is True
+
+
 # ---------------------------------------------------------------------------
 # Server-side auto-approve task — full flow
 # ---------------------------------------------------------------------------

From d0cb1e981e8a6cf2bf254ce7edc78ec8b18d425c Mon Sep 17 00:00:00 2001
From: Zamil Majdy <zamil.majdy@agpt.co>
Date: Fri, 17 Apr 2026 20:11:51 +0700
Subject: [PATCH 44/61] fix(copilot): require fresh decompose_goal+approval per
 build request
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previous gate (has_pending_decomposition) only blocked when decompose_goal
was called but not yet approved. It missed the case where the LLM skipped
decompose_goal entirely on follow-up requests — if a session already had
a prior completed decomposition, the gate returned False and let a fresh
create_agent through without any new plan/approval.

Tighter rule (needs_build_plan_approval): the most recent user message
must be an approval (contains 'approved', case-insensitive) AND a
decompose_goal tool_call must exist in the session before that approval.
This forces the LLM to call decompose_goal for every new build request,
end its turn, and only resume building after the user responds.
---
 .../backend/copilot/tools/create_agent.py     | 28 +++---
 .../backend/copilot/tools/decompose_goal.py   | 60 ++++++++-----
 .../copilot/tools/decompose_goal_test.py      | 87 ++++++++++++-------
 3 files changed, 109 insertions(+), 66 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/create_agent.py b/autogpt_platform/backend/backend/copilot/tools/create_agent.py
index 8ba85af41800..d7b0ebd364ce 100644
--- a/autogpt_platform/backend/backend/copilot/tools/create_agent.py
+++ b/autogpt_platform/backend/backend/copilot/tools/create_agent.py
@@ -8,7 +8,7 @@
 
 from .agent_generator.pipeline import fetch_library_agents, fix_validate_and_save
 from .base import BaseTool
-from .decompose_goal import has_pending_decomposition
+from .decompose_goal import needs_build_plan_approval
 from .models import ErrorResponse, ToolResponseBase
 
 logger = logging.getLogger(__name__)
@@ -71,22 +71,22 @@ async def _execute(
     ) -> ToolResponseBase:
         session_id = session.session_id if session else None
 
-        # Enforce the decompose_goal approval gate. The LLM is instructed via
-        # ``agent_generation_guide.md`` to STOP after decompose_goal until the
-        # user approves, but natural-language instructions alone are not
-        # reliable — without this gate, the LLM has been observed calling
-        # ``decompose_goal`` and ``create_agent`` in the same turn, building
-        # the agent while the user is still mid-countdown.
-        if session and has_pending_decomposition(session):
+        # Enforce the decompose_goal approval gate at the code level.
+        # Prompt-only "STOP" is unreliable: the LLM has been observed
+        # (a) calling decompose_goal + create_agent in the same turn and
+        # (b) skipping decompose_goal entirely on follow-up build requests.
+        # Require that the most recent user message is an approval AND a
+        # decompose_goal call exists before it in the session.
+        if session and needs_build_plan_approval(session):
             return ErrorResponse(
                 message=(
-                    "A build plan is awaiting user approval. Do not call "
-                    "create_agent until the user responds with Approved "
-                    "(or Approved with modifications). End your turn now — "
-                    "the platform will resume the conversation once the user "
-                    "responds."
+                    "You must call decompose_goal first and wait for user "
+                    "approval before calling create_agent. Call decompose_goal "
+                    "now with the build steps, then end your turn — the "
+                    "platform will resume the conversation after the user "
+                    "responds with Approved (or Approved with modifications)."
                 ),
-                error="decomposition_pending_approval",
+                error="build_plan_approval_required",
                 session_id=session_id,
             )
 
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 9ee7cc50afcc..a4b53f48ec70 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -45,34 +45,52 @@
 _pending_auto_approvals: dict[str, asyncio.Task] = {}
 
 
-def has_pending_decomposition(session: ChatSession) -> bool:
-    """Return True if the most recent ``decompose_goal`` tool call in the
-    session has not yet been followed by a user message.
-
-    Used by build tools (create_agent, edit_agent, fix_agent_graph, …) to
-    enforce the "STOP — do not proceed until the user approves" gate from
-    ``agent_generation_guide.md`` at the *code* level. The natural-language
-    instruction alone is not enough — the LLM has been observed calling
-    ``decompose_goal`` and ``create_agent`` in the same turn, building the
-    agent while the user is still mid-countdown. This predicate lets build
-    tools refuse when approval is still pending.
-
-    Scans messages in reverse, returning:
-    - True  → a ``decompose_goal`` tool call exists with no user message after it
-    - False → no ``decompose_goal`` call, or the most recent one has already
-              been answered by a user message (Approve / Modify / other)
+_APPROVAL_MARKERS = ("approved",)
+
+
+def needs_build_plan_approval(session: ChatSession) -> bool:
+    """Return True if the current build must be blocked pending decomposition
+    approval.
+
+    Enforces the "STOP — do not proceed until the user approves" gate from
+    ``agent_generation_guide.md`` at the *code* level. Natural-language
+    instruction alone is not enough — the LLM has been observed:
+    1. Calling ``decompose_goal`` and ``create_agent`` in the same turn
+       (building while the user is mid-countdown), AND
+    2. Skipping ``decompose_goal`` entirely and jumping straight to
+       ``create_agent`` on follow-up build requests when the session
+       already contains a prior resolved decomposition.
+
+    Rule: the most recent user message must be an approval message
+    (contains "approved", case-insensitive) AND a ``decompose_goal`` tool
+    call must exist somewhere in the session before that approval.
+
+    - Fresh "build me X" request without decomposition → block.
+    - New build request after a previous completed build → block until
+      a new decompose_goal + approval cycle runs.
+    - decompose_goal called but user hasn't responded yet → block.
+    - User said "Approved" after decompose_goal → allow.
     """
+    last_user_idx = -1
     for i in range(len(session.messages) - 1, -1, -1):
+        if session.messages[i].role == "user":
+            last_user_idx = i
+            break
+    if last_user_idx < 0:
+        return True
+
+    last_user_content = (session.messages[last_user_idx].content or "").lower()
+    if not any(marker in last_user_content for marker in _APPROVAL_MARKERS):
+        return True
+
+    for i in range(last_user_idx - 1, -1, -1):
         msg = session.messages[i]
-        if msg.role == "user":
-            # A user message without a prior decompose_goal = nothing pending.
-            return False
         if msg.role == "assistant" and msg.tool_calls:
             for tc in msg.tool_calls:
                 name = (tc.get("function") or {}).get("name") or tc.get("name")
                 if name == "decompose_goal":
-                    return True
-    return False
+                    return False
+    return True
 
 
 def _no_user_action_since(baseline_index: int):
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index c6900627f225..e059f36ac728 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -16,7 +16,7 @@
     DecomposeGoalTool,
     _no_user_action_since,
     cancel_auto_approve,
-    has_pending_decomposition,
+    needs_build_plan_approval,
 )
 from .models import ErrorResponse, TaskDecompositionResponse
 
@@ -347,7 +347,7 @@ def test_predicate_handles_messages_with_none_sequence():
 
 
 # ---------------------------------------------------------------------------
-# has_pending_decomposition — build-tool approval gate
+# needs_build_plan_approval — build-tool approval gate
 # ---------------------------------------------------------------------------
 
 
@@ -359,67 +359,92 @@ def _decompose_tool_call() -> dict:
     }
 
 
-def test_pending_decomposition_true_when_no_user_after_call():
-    """LLM called decompose_goal but user hasn't responded yet."""
+def test_needs_approval_blocks_when_no_decompose_in_session():
+    """LLM tries to build without calling decompose_goal at all."""
     session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Build me an agent"))
+    assert needs_build_plan_approval(session) is True
+
+
+def test_needs_approval_blocks_when_last_user_is_not_approval():
+    """Even with a decompose_goal earlier, a fresh non-approval user message
+    starts a new build flow that requires its own decomposition."""
+    session = make_session(_USER_ID)
+    session.messages.append(ChatMessage(role="user", content="Build v1"))
     session.messages.append(
         ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
     )
-    session.messages.append(ChatMessage(role="tool", content="{...plan...}"))
-    assert has_pending_decomposition(session) is True
+    session.messages.append(ChatMessage(role="tool", content="{plan v1}"))
+    session.messages.append(ChatMessage(role="user", content="Approved"))
+    session.messages.append(ChatMessage(role="assistant", content="agent built."))
+    # User asks for a second build — LLM must call decompose_goal again.
+    session.messages.append(ChatMessage(role="user", content="Now build v2"))
+    assert needs_build_plan_approval(session) is True
 
 
-def test_pending_decomposition_false_after_user_approves():
-    """User approved — downstream tools should be unblocked."""
+def test_needs_approval_allows_when_user_approved_after_decompose():
+    """User said "Approved" after a decompose_goal → build may proceed."""
     session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
         ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
     )
-    session.messages.append(ChatMessage(role="tool", content="{...plan...}"))
+    session.messages.append(ChatMessage(role="tool", content="{plan}"))
     session.messages.append(
         ChatMessage(role="user", content="Approved. Please build the agent.")
     )
-    assert has_pending_decomposition(session) is False
+    assert needs_build_plan_approval(session) is False
 
 
-def test_pending_decomposition_false_when_no_decompose_call():
-    """Sessions without decompose_goal are never blocked."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Change the prompt"))
-    session.messages.append(ChatMessage(role="assistant", content="Sure, will do."))
-    assert has_pending_decomposition(session) is False
-
-
-def test_pending_decomposition_ignores_assistant_text_without_tool_calls():
-    """Assistant's text after decompose_goal doesn't count as user action."""
+def test_needs_approval_allows_modified_approval():
+    """Approved with modifications also counts as approval."""
     session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
         ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
     )
-    session.messages.append(ChatMessage(role="tool", content="{...plan...}"))
-    session.messages.append(ChatMessage(role="assistant", content="Plan is ready."))
-    assert has_pending_decomposition(session) is True
+    session.messages.append(ChatMessage(role="tool", content="{plan}"))
+    session.messages.append(
+        ChatMessage(
+            role="user",
+            content="Approved with modifications. Please build the agent following these steps: ...",
+        )
+    )
+    assert needs_build_plan_approval(session) is False
 
 
-def test_pending_decomposition_scans_most_recent_call():
-    """Only the most recent decompose_goal matters; older ones are irrelevant."""
+def test_needs_approval_blocks_same_turn_decompose_and_build():
+    """LLM calls decompose_goal then immediately tries create_agent in the
+    same turn — the last user message is still the original build request,
+    not an approval."""
     session = make_session(_USER_ID)
-    # Old cycle: decomposed, approved, built.
-    session.messages.append(ChatMessage(role="user", content="Build v1"))
+    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
         ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
     )
-    session.messages.append(ChatMessage(role="tool", content="{plan v1}"))
+    session.messages.append(ChatMessage(role="tool", content="{plan}"))
+    # No user message yet — still mid-countdown.
+    assert needs_build_plan_approval(session) is True
+
+
+def test_needs_approval_blocks_approval_without_prior_decompose():
+    """User spontaneously says "Approved" but no decompose_goal was ever
+    called — the LLM did not show a plan, so the gate stays closed."""
+    session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Approved"))
-    # New cycle: decomposed, still awaiting approval.
+    assert needs_build_plan_approval(session) is True
+
+
+def test_needs_approval_case_insensitive():
+    """Approval detection is case-insensitive."""
+    session = make_session(_USER_ID)
+    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
         ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
     )
-    session.messages.append(ChatMessage(role="tool", content="{plan v2}"))
-    assert has_pending_decomposition(session) is True
+    session.messages.append(ChatMessage(role="tool", content="{plan}"))
+    session.messages.append(ChatMessage(role="user", content="APPROVED, go."))
+    assert needs_build_plan_approval(session) is False
 
 
 # ---------------------------------------------------------------------------

From 2b24ef5b0746c1b58593f59968efd67b7dd15047 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Mon, 20 Apr 2026 11:24:12 +0200
Subject: [PATCH 45/61] fix(copilot): resolve merge conflict with dev + fix
 test failures

- Resolve conflict in create_agent.py: keep both require_guide_read
  gate (from dev) and needs_build_plan_approval gate (from this branch)
- Fix create_agent_test.py: add decompose_goal + approval history to
  test sessions so needs_build_plan_approval gate passes
- Bump tool schema char budget from 32000 to 34000 (new decompose_goal
  tool descriptions pushed it past the old limit)
- Fix test_schedule_auto_approve_creates_task: use dynamic baseline
  (make_session now pre-populates guide_read message)
- Fix ruff F841 unused variable errors from dev merge
- Re-export openapi.json

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../copilot/tools/create_agent_test.py        | 27 ++++++++++++++++++-
 .../backend/copilot/tools/tool_schema_test.py |  4 +--
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py b/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py
index 2a9592b81ba2..af470b58342d 100644
--- a/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py
@@ -4,6 +4,7 @@
 
 import pytest
 
+from backend.copilot.model import ChatMessage
 from backend.copilot.tools.create_agent import CreateAgentTool
 from backend.copilot.tools.models import AgentPreviewResponse, ErrorResponse
 
@@ -13,6 +14,28 @@
 _PIPELINE = "backend.copilot.tools.agent_generator.pipeline"
 
 
+def _add_approval_history(session):
+    """Add decompose_goal + user approval to the session so the
+    needs_build_plan_approval gate passes."""
+    session.messages.append(
+        ChatMessage(
+            role="assistant",
+            content="",
+            tool_calls=[
+                {
+                    "id": "call_decompose",
+                    "type": "function",
+                    "function": {"name": "decompose_goal", "arguments": "{}"},
+                }
+            ],
+        )
+    )
+    session.messages.append(ChatMessage(role="tool", content="{plan}"))
+    session.messages.append(
+        ChatMessage(role="user", content="Approved. Please build the agent.")
+    )
+
+
 @pytest.fixture
 def tool():
     return CreateAgentTool()
@@ -20,7 +43,9 @@ def tool():
 
 @pytest.fixture
 def session():
-    return make_session(_TEST_USER_ID)
+    s = make_session(_TEST_USER_ID)
+    _add_approval_history(s)
+    return s
 
 
 # ── Input validation tests ──────────────────────────────────────────────
diff --git a/autogpt_platform/backend/backend/copilot/tools/tool_schema_test.py b/autogpt_platform/backend/backend/copilot/tools/tool_schema_test.py
index 05a7e4cbfb80..d3ef52d9e1b0 100644
--- a/autogpt_platform/backend/backend/copilot/tools/tool_schema_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/tool_schema_test.py
@@ -14,8 +14,8 @@
 
 from backend.copilot.tools import TOOL_REGISTRY
 
-# Character budget (~4 chars/token heuristic, targeting ~8000 tokens)
-_CHAR_BUDGET = 32_000
+# Character budget (~4 chars/token heuristic, targeting ~8500 tokens)
+_CHAR_BUDGET = 34_000
 
 
 @pytest.fixture(scope="module")

From 1ec30ab1304937e3394e99a358bdd1efe5fb1835 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 21 Apr 2026 09:34:11 +0200
Subject: [PATCH 46/61] refactor(copilot): use run_copilot_turn_via_queue for
 auto-approve
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the manual append_message_if + stream_registry.create_session +
enqueue_copilot_turn logic in _run_auto_approve with Zamil's canonical
run_copilot_turn_via_queue helper from session_waiter.py. This helper
handles "add or queue based on session state" consistently — the same
path used by run_sub_session, AutoPilotBlock, and the frontend.

- If session is idle: creates stream registry entry + enqueues turn
- If turn is in flight: queues into pending buffer for mid-turn drain
- timeout=0 makes it fire-and-forget

Removed: _no_user_action_since predicate, append_message_if import,
baseline_index parameter, manual stream_registry + enqueue calls.

Kept: Redis cancel flag for cross-process Modify cancellation,
_pending_auto_approvals dict for in-process task cancel, client-side
approve() at T=60 + server at T=65.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py   | 101 ++---------
 .../copilot/tools/decompose_goal_test.py      | 167 ++----------------
 2 files changed, 37 insertions(+), 231 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index a4b53f48ec70..5c2fd4e35f21 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -3,9 +3,8 @@
 import asyncio
 import logging
 from typing import Any
-from uuid import uuid4
 
-from backend.copilot.model import ChatMessage, ChatSession, append_message_if
+from backend.copilot.model import ChatSession
 from backend.data.redis_client import get_redis_async
 
 from .base import BaseTool
@@ -93,44 +92,12 @@ def needs_build_plan_approval(session: ChatSession) -> bool:
     return True
 
 
-def _no_user_action_since(baseline_index: int):
-    """Predicate: returns True iff no ``role == "user"`` message exists at
-    or after ``baseline_index`` in the session message list.
-
-    Why an index instead of ``ChatMessage.sequence``: ``_save_session_to_db``
-    persists messages with auto-assigned sequences in the DB but does NOT
-    write those sequences back onto the in-memory ``ChatMessage`` objects,
-    and ``cache_chat_session`` writes the in-memory copy to Redis. So when
-    this predicate later loads the session from cache, freshly-appended
-    messages have ``sequence=None``, which would falsely register as 0 and
-    miss them entirely — the predicate would treat the user's manual
-    "Approved" as if it never happened, and the auto-approve would fire a
-    duplicate after the agent build had already completed. Indices are
-    monotonic and require no DB-side bookkeeping.
-    """
-
-    def _check(session: ChatSession) -> bool:
-        for m in session.messages[baseline_index:]:
-            if m.role == "user":
-                return False
-        return True
-
-    return _check
-
-
-async def _run_auto_approve(
-    session_id: str,
-    user_id: str | None,
-    baseline_index: int,
-) -> None:
-    """Wait the server-side timeout and inject a synthetic approval if the
-    user has not acted in the meantime.
+async def _run_auto_approve(session_id: str, user_id: str | None) -> None:
+    """Wait the server-side timeout and dispatch the approval via
+    ``run_copilot_turn_via_queue`` — the canonical helper that queues the
+    message if a turn is already in flight, or starts a new turn if idle.
 
     Cancelled when the user clicks "Modify" (via ``cancel_auto_approve``).
-
-    Limitation: this lives in the executor process; if the worker restarts
-    during the wait, the pending approval is lost (the user falls back to
-    manual approve). Restart-resilience would need a Redis-backed scheduler.
     """
     try:
         await asyncio.sleep(AUTO_APPROVE_SERVER_SECONDS)
@@ -144,45 +111,22 @@ async def _run_auto_approve(
             )
             return
 
-        approval = ChatMessage(role="user", content=AUTO_APPROVE_MESSAGE)
-        result = await append_message_if(
-            session_id=session_id,
-            message=approval,
-            predicate=_no_user_action_since(baseline_index),
-        )
-        if result is None:
-            # User already acted (or the session is gone) — nothing to do.
-            return
-
-        # Local imports avoid a circular dependency between this module and
-        # the executor / API stream registry packages.
-        from backend.copilot import stream_registry
-        from backend.copilot.executor.utils import enqueue_copilot_turn
+        from backend.copilot.sdk.session_waiter import run_copilot_turn_via_queue
 
-        turn_id = str(uuid4())
-        await stream_registry.create_session(
+        outcome, result = await run_copilot_turn_via_queue(
             session_id=session_id,
             user_id=user_id or "",
-            tool_call_id="chat_stream",
-            tool_name="chat",
-            turn_id=turn_id,
+            message=AUTO_APPROVE_MESSAGE,
+            timeout=0,
+            tool_call_id="auto_approve",
+            tool_name="decompose_goal_auto_approve",
+        )
+        logger.info(
+            "decompose_goal auto-approve fired for session %s (outcome=%s, queued=%s)",
+            session_id,
+            outcome,
+            result.queued,
         )
-        try:
-            await enqueue_copilot_turn(
-                session_id=session_id,
-                user_id=user_id,
-                message=AUTO_APPROVE_MESSAGE,
-                turn_id=turn_id,
-                is_user_message=True,
-            )
-        except Exception:
-            # If enqueueing fails, mark the session completed so it doesn't
-            # stay stuck in "running" state in the stream registry forever.
-            await stream_registry.mark_session_completed(
-                session_id, error_message="Auto-approve enqueue failed"
-            )
-            raise
-        logger.info("decompose_goal auto-approve fired for session %s", session_id)
     except asyncio.CancelledError:
         raise
     except Exception:
@@ -226,13 +170,7 @@ async def cancel_auto_approve(session_id: str) -> bool:
 async def _schedule_auto_approve(
     session_id: str | None, user_id: str | None, session: ChatSession
 ) -> None:
-    """Schedule the fire-and-forget auto-approve task for this session.
-
-    The baseline is the current message-list length: any message that
-    arrives at or after this index is "after the decomposition", so a
-    user message there means the user (or a follow-up turn) has acted
-    and the auto-approve should be skipped.
-    """
+    """Schedule the fire-and-forget auto-approve task for this session."""
     if not session_id:
         return
     # Cancel any existing pending approval for this session (e.g. if the
@@ -244,8 +182,7 @@ async def _schedule_auto_approve(
     # the new auto-approve task isn't incorrectly suppressed.
     redis = await get_redis_async()
     await redis.delete(f"{_CANCEL_KEY_PREFIX}{session_id}")
-    baseline_index = len(session.messages)
-    task = asyncio.create_task(_run_auto_approve(session_id, user_id, baseline_index))
+    task = asyncio.create_task(_run_auto_approve(session_id, user_id))
     _pending_auto_approvals[session_id] = task
     # Only remove from dict if this task is still the current one — a
     # cancelled old task's callback must not clobber a newly-scheduled one.
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index de0ed8dcad66..df68392d5755 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -14,7 +14,6 @@
     AUTO_APPROVE_CLIENT_SECONDS,
     DEFAULT_ACTION,
     DecomposeGoalTool,
-    _no_user_action_since,
     cancel_auto_approve,
     needs_build_plan_approval,
 )
@@ -292,60 +291,6 @@ async def test_response_includes_created_at(tool: DecomposeGoalTool, session):
     assert before <= result.created_at <= after
 
 
-# ---------------------------------------------------------------------------
-# Predicate: _no_user_action_since
-# ---------------------------------------------------------------------------
-
-
-def test_predicate_passes_when_no_user_messages_after_baseline():
-    session = make_session(_USER_ID)
-    # Two pre-existing messages (indices 0, 1).
-    session.messages.append(ChatMessage(role="user", content="initial"))
-    session.messages.append(ChatMessage(role="assistant", content="tool call"))
-    # Tool result lands at index 2 — this is what the executor appends after
-    # _execute returns. baseline_index was captured at 2 inside _execute.
-    session.messages.append(ChatMessage(role="tool", content="{...}"))
-    assert _no_user_action_since(2)(session) is True
-
-
-def test_predicate_rejects_when_user_message_after_baseline():
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="initial"))
-    session.messages.append(ChatMessage(role="assistant", content="tool call"))
-    session.messages.append(ChatMessage(role="tool", content="{...}"))
-    session.messages.append(ChatMessage(role="user", content="Approved"))
-    assert _no_user_action_since(2)(session) is False
-
-
-def test_predicate_ignores_assistant_messages_after_baseline():
-    """Only user messages count as 'user action' — assistant messages are
-    just the LLM continuing on its own."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="initial"))
-    session.messages.append(ChatMessage(role="assistant", content="tool call"))
-    session.messages.append(ChatMessage(role="tool", content="{...}"))
-    session.messages.append(ChatMessage(role="assistant", content="summary"))
-    assert _no_user_action_since(2)(session) is True
-
-
-def test_predicate_handles_messages_with_none_sequence():
-    """Regression: the previous sequence-based predicate ignored messages
-    whose sequence was None (which is what cached/in-memory messages have
-    until they're round-tripped through the DB), causing the auto-approve
-    to fire after the user had already manually approved. The new
-    index-based predicate must catch user messages regardless of sequence.
-    """
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="initial"))
-    session.messages.append(ChatMessage(role="assistant", content="tool call"))
-    session.messages.append(ChatMessage(role="tool", content="{...}"))
-    # Sequence intentionally None — the cache often returns this state.
-    user_msg = ChatMessage(role="user", content="Approved", sequence=None)
-    session.messages.append(user_msg)
-    assert user_msg.sequence is None
-    assert _no_user_action_since(2)(session) is False
-
-
 # ---------------------------------------------------------------------------
 # needs_build_plan_approval — build-tool approval gate
 # ---------------------------------------------------------------------------
@@ -448,7 +393,7 @@ def test_needs_approval_case_insensitive():
 
 
 # ---------------------------------------------------------------------------
-# Server-side auto-approve task — full flow
+# Server-side auto-approve task — uses run_copilot_turn_via_queue
 # ---------------------------------------------------------------------------
 
 
@@ -474,98 +419,34 @@ def _stub_redis():
 
 
 @pytest.mark.asyncio
-async def test_auto_approve_fires_when_user_idle():
-    """When no user message is appended after the baseline sequence, the
-    task should append the synthetic approval and enqueue a new turn."""
-    session_id = "session-auto-approve-idle"
-
-    captured_message = {}
-
-    async def fake_append_message_if(session_id, message, predicate):
-        captured_message["msg"] = message
-        return make_session(_USER_ID)
-
-    fake_enqueue = AsyncMock()
-    fake_create_session = AsyncMock()
+async def test_auto_approve_dispatches_via_queue_helper():
+    """_run_auto_approve should delegate to run_copilot_turn_via_queue."""
+    fake_dispatch = AsyncMock(return_value=("completed", None))
 
     with (
         _stub_redis(),
         patch(
-            "backend.copilot.tools.decompose_goal.append_message_if",
-            new=fake_append_message_if,
+            "backend.copilot.sdk.session_waiter.run_copilot_turn_via_queue",
+            new=fake_dispatch,
         ),
         patch(
             "backend.copilot.tools.decompose_goal.AUTO_APPROVE_SERVER_SECONDS",
             0,
         ),
-        patch(
-            "backend.copilot.executor.utils.enqueue_copilot_turn",
-            new=fake_enqueue,
-        ),
-        patch(
-            "backend.copilot.stream_registry.create_session",
-            new=fake_create_session,
-        ),
     ):
-        await decompose_goal_module._run_auto_approve(
-            session_id=session_id,
-            user_id=_USER_ID,
-            baseline_index=5,
-        )
+        await decompose_goal_module._run_auto_approve("session-idle", _USER_ID)
 
-    assert captured_message["msg"].role == "user"
-    assert captured_message["msg"].content == "Approved. Please build the agent."
-    fake_create_session.assert_awaited_once()
-    fake_enqueue.assert_awaited_once()
-    assert fake_enqueue.await_args is not None
-    enqueue_kwargs = fake_enqueue.await_args.kwargs
-    assert enqueue_kwargs["session_id"] == session_id
-    assert enqueue_kwargs["message"] == "Approved. Please build the agent."
-    assert enqueue_kwargs["is_user_message"] is True
-
-
-@pytest.mark.asyncio
-async def test_auto_approve_skips_when_user_already_acted():
-    """If append_message_if returns None (predicate rejected because the
-    user already sent a message), no turn should be enqueued."""
-    fake_append_message_if = AsyncMock(return_value=None)
-    fake_enqueue = AsyncMock()
-    fake_create_session = AsyncMock()
-
-    with (
-        _stub_redis(),
-        patch(
-            "backend.copilot.tools.decompose_goal.append_message_if",
-            new=fake_append_message_if,
-        ),
-        patch(
-            "backend.copilot.tools.decompose_goal.AUTO_APPROVE_SERVER_SECONDS",
-            0,
-        ),
-        patch(
-            "backend.copilot.executor.utils.enqueue_copilot_turn",
-            new=fake_enqueue,
-        ),
-        patch(
-            "backend.copilot.stream_registry.create_session",
-            new=fake_create_session,
-        ),
-    ):
-        await decompose_goal_module._run_auto_approve(
-            session_id="session-acted",
-            user_id=_USER_ID,
-            baseline_index=5,
-        )
-
-    fake_append_message_if.assert_awaited_once()
-    fake_enqueue.assert_not_awaited()
-    fake_create_session.assert_not_awaited()
+    fake_dispatch.assert_awaited_once()
+    call_kwargs = fake_dispatch.await_args.kwargs
+    assert call_kwargs["session_id"] == "session-idle"
+    assert call_kwargs["message"] == "Approved. Please build the agent."
+    assert call_kwargs["timeout"] == 0
+    assert call_kwargs["tool_name"] == "decompose_goal_auto_approve"
 
 
 @pytest.mark.asyncio
 async def test_auto_approve_swallows_unexpected_errors():
-    """A failure inside the task must never propagate — the worker should
-    keep running."""
+    """A failure inside the task must never propagate."""
 
     async def boom(*args, **kwargs):
         raise RuntimeError("kaboom")
@@ -573,7 +454,7 @@ async def boom(*args, **kwargs):
     with (
         _stub_redis(),
         patch(
-            "backend.copilot.tools.decompose_goal.append_message_if",
+            "backend.copilot.sdk.session_waiter.run_copilot_turn_via_queue",
             new=boom,
         ),
         patch(
@@ -581,19 +462,12 @@ async def boom(*args, **kwargs):
             0,
         ),
     ):
-        # Should not raise.
-        await decompose_goal_module._run_auto_approve(
-            session_id="session-error",
-            user_id=_USER_ID,
-            baseline_index=0,
-        )
+        await decompose_goal_module._run_auto_approve("session-error", None)
 
 
 @pytest.mark.asyncio
 async def test_schedule_auto_approve_creates_task(monkeypatch):
-    """_schedule_auto_approve should add a task to the tracking set and
-    auto-remove it on completion. The baseline passed to _run_auto_approve
-    must be the current message-list length at schedule time."""
+    """_schedule_auto_approve should add a task to the tracking dict."""
     monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 0)
     fake_run = AsyncMock()
     monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
@@ -604,10 +478,6 @@ async def test_schedule_auto_approve_creates_task(monkeypatch):
     )
 
     session = make_session(_USER_ID)
-    # make_session pre-populates 1 message (guide_read). Add 2 more.
-    session.messages.append(ChatMessage(role="user", content="initial"))
-    session.messages.append(ChatMessage(role="assistant", content="tool call"))
-    expected_baseline = len(session.messages)
 
     await _REAL_SCHEDULE_AUTO_APPROVE(
         session_id="session-schedule",
@@ -615,12 +485,11 @@ async def test_schedule_auto_approve_creates_task(monkeypatch):
         session=session,
     )
 
-    # Wait for the scheduled task to complete.
     await asyncio.sleep(0)
     while decompose_goal_module._pending_auto_approvals:
         await asyncio.sleep(0)
 
-    fake_run.assert_awaited_once_with("session-schedule", _USER_ID, expected_baseline)
+    fake_run.assert_awaited_once_with("session-schedule", _USER_ID)
 
 
 @pytest.mark.asyncio

From 40d56ede76fcbb78836c3bcb3c218ab0b3bd19c7 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 21 Apr 2026 10:49:14 +0200
Subject: [PATCH 47/61] fix(copilot): skip server auto-approve when turn is
 already in flight

The server's run_copilot_turn_via_queue at T=65 queued a duplicate
"Approved" mid-turn because the queue path has no dedup.

Fix: check is_turn_in_flight() before dispatching. If a turn is already
running (client sent "Approved" at T=60, or user typed approval in
chat), skip entirely. Only fire when the session is idle (client closed
the tab).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py       | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 5c2fd4e35f21..892b0ad188a1 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -111,6 +111,18 @@ async def _run_auto_approve(session_id: str, user_id: str | None) -> None:
             )
             return
 
+        # Skip if a turn is already in flight — the client already sent
+        # "Approved" and started the build. Only fire when the session is
+        # idle (client closed the tab).
+        from backend.copilot.pending_message_helpers import is_turn_in_flight
+
+        if await is_turn_in_flight(session_id):
+            logger.info(
+                "decompose_goal auto-approve skipped (turn in flight) for session %s",
+                session_id,
+            )
+            return
+
         from backend.copilot.sdk.session_waiter import run_copilot_turn_via_queue
 
         outcome, result = await run_copilot_turn_via_queue(
@@ -122,10 +134,9 @@ async def _run_auto_approve(session_id: str, user_id: str | None) -> None:
             tool_name="decompose_goal_auto_approve",
         )
         logger.info(
-            "decompose_goal auto-approve fired for session %s (outcome=%s, queued=%s)",
+            "decompose_goal auto-approve fired for session %s (outcome=%s)",
             session_id,
             outcome,
-            result.queued,
         )
     except asyncio.CancelledError:
         raise

From 51c16c687d3d30a9871492602c32f8ffeddb00f5 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 21 Apr 2026 13:46:40 +0200
Subject: [PATCH 48/61] fix(copilot): any user response after decompose_goal
 unblocks build gate

The keyword-matching gate (_APPROVAL_MARKERS = "approved") rejected
free-text approvals like "Sure", forcing the LLM to re-decompose and
eventually producing duplicate sub-instructions + auto-approve messages.

Replace with: any user message after the latest decompose_goal tool call
passes the gate. The LLM interprets intent (build, modify, or reject).
The gate only blocks same-turn builds where no user response exists yet.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py   | 64 +++++++++----------
 .../copilot/tools/decompose_goal_test.py      | 52 +++++----------
 2 files changed, 44 insertions(+), 72 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 892b0ad188a1..17137d32de28 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -44,51 +44,45 @@
 _pending_auto_approvals: dict[str, asyncio.Task] = {}
 
 
-_APPROVAL_MARKERS = ("approved",)
-
-
 def needs_build_plan_approval(session: ChatSession) -> bool:
-    """Return True if the current build must be blocked pending decomposition
-    approval.
+    """Return True if the current build must be blocked pending user response.
 
-    Enforces the "STOP — do not proceed until the user approves" gate from
+    Enforces the "STOP — do not proceed until the user responds" gate from
     ``agent_generation_guide.md`` at the *code* level. Natural-language
-    instruction alone is not enough — the LLM has been observed:
-    1. Calling ``decompose_goal`` and ``create_agent`` in the same turn
-       (building while the user is mid-countdown), AND
-    2. Skipping ``decompose_goal`` entirely and jumping straight to
-       ``create_agent`` on follow-up build requests when the session
-       already contains a prior resolved decomposition.
-
-    Rule: the most recent user message must be an approval message
-    (contains "approved", case-insensitive) AND a ``decompose_goal`` tool
-    call must exist somewhere in the session before that approval.
-
-    - Fresh "build me X" request without decomposition → block.
-    - New build request after a previous completed build → block until
-      a new decompose_goal + approval cycle runs.
-    - decompose_goal called but user hasn't responded yet → block.
-    - User said "Approved" after decompose_goal → allow.
+    instruction alone is not enough — the LLM has been observed calling
+    ``decompose_goal`` and ``create_agent`` in the same turn.
+
+    Rule: a ``decompose_goal`` tool call must exist in the session AND at
+    least one user message must appear after it. The gate does NOT check
+    *what* the user said — the LLM interprets the intent (build, modify,
+    or reject). The gate only blocks same-turn builds where the user hasn't
+    responded at all.
+
+    - No decompose_goal in session → block (must decompose first).
+    - decompose_goal called but no user response yet → block.
+    - Any user message after decompose_goal → allow (LLM decides).
     """
-    last_user_idx = -1
+    # Walk backward to find the latest decompose_goal tool call.
+    decompose_idx = -1
     for i in range(len(session.messages) - 1, -1, -1):
-        if session.messages[i].role == "user":
-            last_user_idx = i
-            break
-    if last_user_idx < 0:
-        return True
-
-    last_user_content = (session.messages[last_user_idx].content or "").lower()
-    if not any(marker in last_user_content for marker in _APPROVAL_MARKERS):
-        return True
-
-    for i in range(last_user_idx - 1, -1, -1):
         msg = session.messages[i]
         if msg.role == "assistant" and msg.tool_calls:
             for tc in msg.tool_calls:
                 name = (tc.get("function") or {}).get("name") or tc.get("name")
                 if name == "decompose_goal":
-                    return False
+                    decompose_idx = i
+                    break
+            if decompose_idx >= 0:
+                break
+
+    if decompose_idx < 0:
+        return True
+
+    # Any user message after the decompose_goal call unblocks the gate.
+    for msg in session.messages[decompose_idx + 1 :]:
+        if msg.role == "user":
+            return False
+
     return True
 
 
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index df68392d5755..8cfecbc24ccd 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -311,24 +311,20 @@ def test_needs_approval_blocks_when_no_decompose_in_session():
     assert needs_build_plan_approval(session) is True
 
 
-def test_needs_approval_blocks_when_last_user_is_not_approval():
-    """Even with a decompose_goal earlier, a fresh non-approval user message
-    starts a new build flow that requires its own decomposition."""
+def test_needs_approval_allows_any_user_response():
+    """Any user message after decompose_goal unblocks the gate."""
     session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Build v1"))
+    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
         ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
     )
-    session.messages.append(ChatMessage(role="tool", content="{plan v1}"))
-    session.messages.append(ChatMessage(role="user", content="Approved"))
-    session.messages.append(ChatMessage(role="assistant", content="agent built."))
-    # User asks for a second build — LLM must call decompose_goal again.
-    session.messages.append(ChatMessage(role="user", content="Now build v2"))
-    assert needs_build_plan_approval(session) is True
+    session.messages.append(ChatMessage(role="tool", content="{plan}"))
+    session.messages.append(ChatMessage(role="user", content="Sure"))
+    assert needs_build_plan_approval(session) is False
 
 
-def test_needs_approval_allows_when_user_approved_after_decompose():
-    """User said "Approved" after a decompose_goal → build may proceed."""
+def test_needs_approval_allows_explicit_approval():
+    """Explicit 'Approved' also passes (common from button/auto-approve)."""
     session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
@@ -341,8 +337,8 @@ def test_needs_approval_allows_when_user_approved_after_decompose():
     assert needs_build_plan_approval(session) is False
 
 
-def test_needs_approval_allows_modified_approval():
-    """Approved with modifications also counts as approval."""
+def test_needs_approval_allows_modification_request():
+    """User asking to modify the plan also passes — LLM decides what to do."""
     session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
@@ -350,46 +346,28 @@ def test_needs_approval_allows_modified_approval():
     )
     session.messages.append(ChatMessage(role="tool", content="{plan}"))
     session.messages.append(
-        ChatMessage(
-            role="user",
-            content="Approved with modifications. Please build the agent following these steps: ...",
-        )
+        ChatMessage(role="user", content="Change step 3 to use Gmail instead")
     )
     assert needs_build_plan_approval(session) is False
 
 
 def test_needs_approval_blocks_same_turn_decompose_and_build():
     """LLM calls decompose_goal then immediately tries create_agent in the
-    same turn — the last user message is still the original build request,
-    not an approval."""
+    same turn — no user message after decompose_goal yet."""
     session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Build me an agent"))
     session.messages.append(
         ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
     )
     session.messages.append(ChatMessage(role="tool", content="{plan}"))
-    # No user message yet — still mid-countdown.
-    assert needs_build_plan_approval(session) is True
-
-
-def test_needs_approval_blocks_approval_without_prior_decompose():
-    """User spontaneously says "Approved" but no decompose_goal was ever
-    called — the LLM did not show a plan, so the gate stays closed."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Approved"))
     assert needs_build_plan_approval(session) is True
 
 
-def test_needs_approval_case_insensitive():
-    """Approval detection is case-insensitive."""
+def test_needs_approval_blocks_without_prior_decompose():
+    """No decompose_goal in session → must decompose first."""
     session = make_session(_USER_ID)
     session.messages.append(ChatMessage(role="user", content="Build me an agent"))
-    session.messages.append(
-        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
-    )
-    session.messages.append(ChatMessage(role="tool", content="{plan}"))
-    session.messages.append(ChatMessage(role="user", content="APPROVED, go."))
-    assert needs_build_plan_approval(session) is False
+    assert needs_build_plan_approval(session) is True
 
 
 # ---------------------------------------------------------------------------

From 95362f7881efeec83d0ac20aabd458d4632ed6fa Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 22 Apr 2026 11:14:07 +0200
Subject: [PATCH 49/61] fix(copilot): timer only ticks after turn fully
 finishes

The countdown was ticking during LLM streaming (gated on showActions,
not actionsEnabled), so streaming time ate into the user's review
window. A 10s stream meant only 50s to review the plan.

Gate the interval on actionsEnabled (includes !isMessageStreaming) so
the timer starts at the full countdown duration only after all streaming
completes. For session re-entry, the lazy initializer computes remaining
from created_at. Removes the created_at-based recompute from the live
interval (no longer needed since the timer doesn't tick during streaming
and naive decrement is accurate when the tab is active).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 48 +++++--------------
 1 file changed, 12 insertions(+), 36 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index d60e5a394d22..6f14c8f42055 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -186,43 +186,19 @@ export function DecomposeGoalTool({
     }
   }, [showActions, isEditing]);
 
-  // Re-derive remaining seconds from ``created_at`` on every tick (and on
-  // tab visibility change) instead of decrementing a local counter.
-  // ``setInterval`` is aggressively throttled in backgrounded tabs, so a
-  // naive ``s - 1`` drifts behind wall-clock time — the user could reopen
-  // the tab well past the deadline and still see e.g. "Starting in 45".
-  // Re-deriving keeps the UI in sync with the server-side timer.
-  const createdAt =
-    output && isDecompositionOutput(output) ? output.created_at : undefined;
+  // The timer only ticks once the turn is fully finished (actionsEnabled
+  // includes !isMessageStreaming). This gives the user the full countdown
+  // duration to review the plan after all streaming completes — not from
+  // when the tool returned (which would eat streaming time into the review
+  // window). For session re-entry, the lazy initializer already seeds
+  // secondsLeft from created_at, so the timer resumes correctly.
   useEffect(() => {
-    if (!showActions || !timerActive) return;
-    const deadlineMs = createdAt
-      ? new Date(createdAt).getTime() + countdownSeconds * 1000
-      : null;
-    const hasDeadline = deadlineMs !== null && !Number.isNaN(deadlineMs);
-    function recompute() {
-      if (hasDeadline) {
-        const remaining = Math.max(
-          0,
-          Math.round((deadlineMs - Date.now()) / 1000),
-        );
-        setSecondsLeft(Math.min(countdownSeconds, remaining));
-      } else {
-        // Legacy session with no ``created_at`` — fall back to naive decrement.
-        setSecondsLeft((s) => Math.max(0, s - 1));
-      }
-    }
-    // Only correct stale state for deadline-driven sessions. The legacy
-    // fallback starts from the seeded ``secondsLeft`` and should not
-    // decrement before the first 1s tick elapses.
-    if (hasDeadline) recompute();
-    const interval = setInterval(recompute, 1000);
-    document.addEventListener("visibilitychange", recompute);
-    return () => {
-      clearInterval(interval);
-      document.removeEventListener("visibilitychange", recompute);
-    };
-  }, [showActions, timerActive, part.toolCallId, createdAt, countdownSeconds]);
+    if (!actionsEnabled || !timerActive) return;
+    const interval = setInterval(() => {
+      setSecondsLeft((s) => Math.max(0, s - 1));
+    }, 1000);
+    return () => clearInterval(interval);
+  }, [actionsEnabled, timerActive, part.toolCallId]);
 
   // Auto-approve when countdown reaches 0. The client fires at 60s; the
   // server fires 5s later as a fallback for the "user closed the tab" case.

From 15499722d2cafd764009f7ea8dcbb353c41e3856 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 24 Apr 2026 06:45:37 +0200
Subject: [PATCH 50/61] fix(copilot): stronger prompt to end turn after
 decompose_goal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The LLM sometimes called decompose_goal mid-turn and continued to
find_block or create_agent without waiting for user approval. The
existing "STOP" instruction wasn't forceful enough.

Rewrite to explicitly state decompose_goal MUST be the last tool call
in the turn — no other tools, no text after the result, end the turn
immediately so the user can review and respond.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/sdk/agent_generation_guide.md      | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
index bec82f0c29ee..468ac93893b7 100644
--- a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
+++ b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
@@ -33,8 +33,14 @@ Before running the workflow below, ALWAYS decompose the goal first:
 1. Analyze the user's request and break it into logical build steps (e.g.
    "add input block", "add AI summarizer", "wire blocks together").
 2. Call `decompose_goal` with those steps.
-3. **STOP — do not proceed until the user approves the plan.**
-4. Only after approval, continue with "Workflow for Creating/Editing Agents".
+3. **STOP your turn immediately after `decompose_goal` returns.** Do not
+   call any other tools. Do not generate any text after the tool result.
+   End the turn so the user can review the plan and respond.
+4. Only after the user responds, continue with "Workflow for Creating/
+   Editing Agents".
+
+`decompose_goal` MUST be the last tool call in the turn. Never combine
+it with `find_block`, `create_agent`, or any other tool in the same turn.
 
 For simple goals (1-2 blocks), keep steps brief (2-3 steps).
 For complex goals, use as many steps as needed.

From b1eee6eca47d8eea8a4047fdcddfb69644791f7b Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Fri, 24 Apr 2026 07:00:19 +0200
Subject: [PATCH 51/61] fix(copilot): suppress duplicate text when calling
 decompose_goal
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The LLM was generating a natural-text summary alongside the
decompose_goal tool call, producing both a text plan and the UI card.

Add explicit instruction: do not write any text before or after the
tool call — the platform renders the plan UI automatically.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .../backend/copilot/sdk/agent_generation_guide.md   | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
index 468ac93893b7..edc8a7ca5a18 100644
--- a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
+++ b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
@@ -32,15 +32,18 @@ Before running the workflow below, ALWAYS decompose the goal first:
 
 1. Analyze the user's request and break it into logical build steps (e.g.
    "add input block", "add AI summarizer", "wire blocks together").
-2. Call `decompose_goal` with those steps.
+2. Call `decompose_goal` with those steps. **Do not write any text before
+   or after the tool call** — the platform renders a rich UI card for the
+   plan automatically. Any text you write will duplicate the plan display.
 3. **STOP your turn immediately after `decompose_goal` returns.** Do not
-   call any other tools. Do not generate any text after the tool result.
-   End the turn so the user can review the plan and respond.
+   call any other tools. Do not generate any text. End the turn so the
+   user can review the plan and respond.
 4. Only after the user responds, continue with "Workflow for Creating/
    Editing Agents".
 
-`decompose_goal` MUST be the last tool call in the turn. Never combine
-it with `find_block`, `create_agent`, or any other tool in the same turn.
+`decompose_goal` MUST be the only tool call in the turn, with no
+accompanying text. Never combine it with `find_block`, `create_agent`,
+or any other tool in the same turn.
 
 For simple goals (1-2 blocks), keep steps brief (2-3 steps).
 For complex goals, use as many steps as needed.

From dbab590442b69eca4135e65fa12fc1dd2489e246 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 29 Apr 2026 14:03:32 +0200
Subject: [PATCH 52/61] refactor(copilot): make decompose_goal a
 visibility-only tool

Strip the approval gate, server auto-approve timer, /cancel-auto-approve
endpoint, and the frontend Approve/Modify/edit-mode UI. The plan card now
renders read-only and the LLM continues building in the same turn.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../backend/api/features/chat/routes.py       |  22 --
 .../copilot/sdk/agent_generation_guide.md     |  23 +-
 .../backend/copilot/tools/create_agent.py     |  20 -
 .../copilot/tools/create_agent_test.py        |  27 +-
 .../backend/copilot/tools/decompose_goal.py   | 194 +---------
 .../copilot/tools/decompose_goal_test.py      | 337 +---------------
 .../backend/backend/copilot/tools/models.py   |  20 +-
 .../ChatMessagesContainer.tsx                 |   8 -
 .../__tests__/helpers.test.ts                 |   1 -
 .../components/MessagePartRenderer.tsx        |  13 +-
 .../tools/DecomposeGoal/DecomposeGoal.tsx     | 359 +-----------------
 .../__tests__/DecomposeGoal.test.tsx          | 268 +------------
 .../DecomposeGoal/__tests__/helpers.test.ts   |  90 +----
 .../copilot/tools/DecomposeGoal/helpers.tsx   |  35 --
 .../frontend/src/app/api/openapi.json         |  57 ---
 15 files changed, 45 insertions(+), 1429 deletions(-)

diff --git a/autogpt_platform/backend/backend/api/features/chat/routes.py b/autogpt_platform/backend/backend/api/features/chat/routes.py
index dfad86a36cb5..bb0591276442 100644
--- a/autogpt_platform/backend/backend/api/features/chat/routes.py
+++ b/autogpt_platform/backend/backend/api/features/chat/routes.py
@@ -817,28 +817,6 @@ async def cancel_session_task(
     return CancelSessionResponse(cancelled=True)
 
 
-@router.post(
-    "/sessions/{session_id}/cancel-auto-approve",
-    status_code=200,
-)
-async def cancel_auto_approve_task(
-    session_id: str,
-    user_id: Annotated[str, Security(auth.get_user_id)],
-) -> CancelSessionResponse:
-    """Cancel the pending auto-approve timer for a decompose_goal plan.
-
-    Called by the frontend when the user clicks "Modify" on the build-plan
-    box. Without this, the server-side timer would fire the default
-    "Approved" message while the user is still editing.
-    """
-    await _validate_and_get_session(session_id, user_id)
-
-    from backend.copilot.tools.decompose_goal import cancel_auto_approve
-
-    await cancel_auto_approve(session_id)
-    return CancelSessionResponse(cancelled=True)
-
-
 @router.post(
     "/sessions/{session_id}/stream",
     responses={
diff --git a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
index 0a0cbad48297..b0f7ca340362 100644
--- a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
+++ b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
@@ -26,24 +26,19 @@ Steps:
 **Skip this** when the goal already specifies all dimensions (e.g.
 "scrape prices from Amazon and email me daily").
 
-### Before Building: Goal Decomposition (REQUIRED)
+### Before Building: Show the Plan
 
-Before running the workflow below, ALWAYS decompose the goal first:
+Start agent generation by calling `decompose_goal` once to display your
+build plan to the user as a step-by-step UI card.
 
 1. Analyze the user's request and break it into logical build steps (e.g.
    "add input block", "add AI summarizer", "wire blocks together").
-2. Call `decompose_goal` with those steps. **Do not write any text before
-   or after the tool call** — the platform renders a rich UI card for the
-   plan automatically. Any text you write will duplicate the plan display.
-3. **STOP your turn immediately after `decompose_goal` returns.** Do not
-   call any other tools. Do not generate any text. End the turn so the
-   user can review the plan and respond.
-4. Only after the user responds, continue with "Workflow for Creating/
-   Editing Agents".
-
-`decompose_goal` MUST be the only tool call in the turn, with no
-accompanying text. Never combine it with `find_block`, `create_agent`,
-or any other tool in the same turn.
+2. Call `decompose_goal` with those steps. Do not write any text before
+   or after the tool call — the platform renders the plan UI card
+   automatically, so any extra text duplicates the display.
+3. Continue immediately with the workflow below in the same turn. The
+   plan card is informational only — there is no approval step, no
+   countdown, and no need to wait for the user.
 
 For simple goals (1-2 blocks), keep steps brief (2-3 steps).
 For complex goals, use as many steps as needed.
diff --git a/autogpt_platform/backend/backend/copilot/tools/create_agent.py b/autogpt_platform/backend/backend/copilot/tools/create_agent.py
index 39ae11e85831..a27392fc8e74 100644
--- a/autogpt_platform/backend/backend/copilot/tools/create_agent.py
+++ b/autogpt_platform/backend/backend/copilot/tools/create_agent.py
@@ -8,7 +8,6 @@
 
 from .agent_generator.pipeline import fetch_library_agents, fix_validate_and_save
 from .base import BaseTool
-from .decompose_goal import needs_build_plan_approval
 from .helpers import require_guide_read
 from .models import ErrorResponse, ToolResponseBase
 
@@ -77,25 +76,6 @@ async def _execute(
         if guide_gate is not None:
             return guide_gate
 
-        # Enforce the decompose_goal approval gate at the code level.
-        # Prompt-only "STOP" is unreliable: the LLM has been observed
-        # (a) calling decompose_goal + create_agent in the same turn and
-        # (b) skipping decompose_goal entirely on follow-up build requests.
-        # Require that the most recent user message is an approval AND a
-        # decompose_goal call exists before it in the session.
-        if session and needs_build_plan_approval(session):
-            return ErrorResponse(
-                message=(
-                    "You must call decompose_goal first and wait for user "
-                    "approval before calling create_agent. Call decompose_goal "
-                    "now with the build steps, then end your turn — the "
-                    "platform will resume the conversation after the user "
-                    "responds with Approved (or Approved with modifications)."
-                ),
-                error="build_plan_approval_required",
-                session_id=session_id,
-            )
-
         if not agent_json:
             return ErrorResponse(
                 message=(
diff --git a/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py b/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py
index 19c318d52f71..5bf32342a47e 100644
--- a/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/create_agent_test.py
@@ -4,7 +4,6 @@
 
 import pytest
 
-from backend.copilot.model import ChatMessage
 from backend.copilot.tools.create_agent import CreateAgentTool
 from backend.copilot.tools.models import AgentPreviewResponse, ErrorResponse
 
@@ -14,28 +13,6 @@
 _PIPELINE = "backend.copilot.tools.agent_generator.pipeline"
 
 
-def _add_approval_history(session):
-    """Add decompose_goal + user approval to the session so the
-    needs_build_plan_approval gate passes."""
-    session.messages.append(
-        ChatMessage(
-            role="assistant",
-            content="",
-            tool_calls=[
-                {
-                    "id": "call_decompose",
-                    "type": "function",
-                    "function": {"name": "decompose_goal", "arguments": "{}"},
-                }
-            ],
-        )
-    )
-    session.messages.append(ChatMessage(role="tool", content="{plan}"))
-    session.messages.append(
-        ChatMessage(role="user", content="Approved. Please build the agent.")
-    )
-
-
 @pytest.fixture
 def tool():
     return CreateAgentTool()
@@ -43,9 +20,7 @@ def tool():
 
 @pytest.fixture
 def session():
-    s = make_session(_TEST_USER_ID)
-    _add_approval_history(s)
-    return s
+    return make_session(_TEST_USER_ID)
 
 
 # ── Input validation tests ──────────────────────────────────────────────
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 17137d32de28..91b49806aa12 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -1,11 +1,9 @@
 """DecomposeGoalTool - Breaks agent-building goals into sub-instructions."""
 
-import asyncio
 import logging
 from typing import Any
 
 from backend.copilot.model import ChatSession
-from backend.data.redis_client import get_redis_async
 
 from .base import BaseTool
 from .models import (
@@ -20,185 +18,6 @@
 DEFAULT_ACTION = "add_block"
 VALID_ACTIONS = {"add_block", "connect_blocks", "configure", "add_input", "add_output"}
 
-# Auto-approve countdown — the frontend reads ``auto_approve_seconds`` from the
-# tool response and runs the visible countdown (60s). The server fires 5s later
-# as a fallback for the "user closed the tab" case. The 5s gap ensures the
-# client always fires first when present, creating the SSE subscription that
-# lets the user see the build in real-time. When the server wakes at 65s, it
-# checks the predicate and skips (the client's message is already there).
-AUTO_APPROVE_CLIENT_SECONDS = 60
-AUTO_APPROVE_SERVER_GRACE_SECONDS = 5
-AUTO_APPROVE_SERVER_SECONDS = (
-    AUTO_APPROVE_CLIENT_SECONDS + AUTO_APPROVE_SERVER_GRACE_SECONDS
-)
-AUTO_APPROVE_MESSAGE = "Approved. Please build the agent."
-
-# Redis key prefix for cross-process cancel signalling. The cancel
-# endpoint (AgentServer process) SETs the key; _run_auto_approve
-# (CoPilotExecutor process) checks it before firing.
-_CANCEL_KEY_PREFIX = "copilot:cancel_auto_approve:"
-_CANCEL_KEY_TTL_SECONDS = AUTO_APPROVE_SERVER_SECONDS + 30
-
-# In-process dict for best-effort cancel when both the cancel call and
-# the asyncio task happen to live in the same process (single-worker).
-_pending_auto_approvals: dict[str, asyncio.Task] = {}
-
-
-def needs_build_plan_approval(session: ChatSession) -> bool:
-    """Return True if the current build must be blocked pending user response.
-
-    Enforces the "STOP — do not proceed until the user responds" gate from
-    ``agent_generation_guide.md`` at the *code* level. Natural-language
-    instruction alone is not enough — the LLM has been observed calling
-    ``decompose_goal`` and ``create_agent`` in the same turn.
-
-    Rule: a ``decompose_goal`` tool call must exist in the session AND at
-    least one user message must appear after it. The gate does NOT check
-    *what* the user said — the LLM interprets the intent (build, modify,
-    or reject). The gate only blocks same-turn builds where the user hasn't
-    responded at all.
-
-    - No decompose_goal in session → block (must decompose first).
-    - decompose_goal called but no user response yet → block.
-    - Any user message after decompose_goal → allow (LLM decides).
-    """
-    # Walk backward to find the latest decompose_goal tool call.
-    decompose_idx = -1
-    for i in range(len(session.messages) - 1, -1, -1):
-        msg = session.messages[i]
-        if msg.role == "assistant" and msg.tool_calls:
-            for tc in msg.tool_calls:
-                name = (tc.get("function") or {}).get("name") or tc.get("name")
-                if name == "decompose_goal":
-                    decompose_idx = i
-                    break
-            if decompose_idx >= 0:
-                break
-
-    if decompose_idx < 0:
-        return True
-
-    # Any user message after the decompose_goal call unblocks the gate.
-    for msg in session.messages[decompose_idx + 1 :]:
-        if msg.role == "user":
-            return False
-
-    return True
-
-
-async def _run_auto_approve(session_id: str, user_id: str | None) -> None:
-    """Wait the server-side timeout and dispatch the approval via
-    ``run_copilot_turn_via_queue`` — the canonical helper that queues the
-    message if a turn is already in flight, or starts a new turn if idle.
-
-    Cancelled when the user clicks "Modify" (via ``cancel_auto_approve``).
-    """
-    try:
-        await asyncio.sleep(AUTO_APPROVE_SERVER_SECONDS)
-
-        # Check the cross-process cancel flag set by cancel_auto_approve().
-        redis = await get_redis_async()
-        if await redis.get(f"{_CANCEL_KEY_PREFIX}{session_id}"):
-            logger.info(
-                "decompose_goal auto-approve skipped (cancelled) for session %s",
-                session_id,
-            )
-            return
-
-        # Skip if a turn is already in flight — the client already sent
-        # "Approved" and started the build. Only fire when the session is
-        # idle (client closed the tab).
-        from backend.copilot.pending_message_helpers import is_turn_in_flight
-
-        if await is_turn_in_flight(session_id):
-            logger.info(
-                "decompose_goal auto-approve skipped (turn in flight) for session %s",
-                session_id,
-            )
-            return
-
-        from backend.copilot.sdk.session_waiter import run_copilot_turn_via_queue
-
-        outcome, result = await run_copilot_turn_via_queue(
-            session_id=session_id,
-            user_id=user_id or "",
-            message=AUTO_APPROVE_MESSAGE,
-            timeout=0,
-            tool_call_id="auto_approve",
-            tool_name="decompose_goal_auto_approve",
-        )
-        logger.info(
-            "decompose_goal auto-approve fired for session %s (outcome=%s)",
-            session_id,
-            outcome,
-        )
-    except asyncio.CancelledError:
-        raise
-    except Exception:
-        logger.exception(
-            "decompose_goal auto-approve task failed for session %s",
-            session_id,
-        )
-
-
-async def cancel_auto_approve(session_id: str) -> bool:
-    """Cancel the pending auto-approve task for a session.
-
-    Called by the ``/sessions/{session_id}/cancel-auto-approve`` endpoint
-    when the user clicks "Modify" in the build-plan UI.
-
-    Uses **two** cancellation channels:
-    1. **Redis flag** (cross-process) — the executor checks this before
-       firing. Works even when the cancel endpoint runs in the AgentServer
-       process and the asyncio task lives in the CoPilotExecutor process.
-    2. **In-process task cancel** (best-effort) — if both happen to share
-       the same process, cancels the asyncio task directly.
-    """
-    redis = await get_redis_async()
-    await redis.set(
-        f"{_CANCEL_KEY_PREFIX}{session_id}",
-        "1",
-        ex=_CANCEL_KEY_TTL_SECONDS,
-    )
-    logger.info(
-        "decompose_goal auto-approve cancel flag set for session %s", session_id
-    )
-
-    # Best-effort in-process cancel (no-op if the task is in another process).
-    task = _pending_auto_approvals.pop(session_id, None)
-    if task is not None and not task.done():
-        task.cancel()
-
-    return True
-
-
-async def _schedule_auto_approve(
-    session_id: str | None, user_id: str | None, session: ChatSession
-) -> None:
-    """Schedule the fire-and-forget auto-approve task for this session."""
-    if not session_id:
-        return
-    # Cancel any existing pending approval for this session (e.g. if the
-    # LLM called decompose_goal twice in one turn).
-    old_task = _pending_auto_approvals.pop(session_id, None)
-    if old_task is not None and not old_task.done():
-        old_task.cancel()
-    # Clear any stale Redis cancel flag from a previous Modify click so
-    # the new auto-approve task isn't incorrectly suppressed.
-    redis = await get_redis_async()
-    await redis.delete(f"{_CANCEL_KEY_PREFIX}{session_id}")
-    task = asyncio.create_task(_run_auto_approve(session_id, user_id))
-    _pending_auto_approvals[session_id] = task
-    # Only remove from dict if this task is still the current one — a
-    # cancelled old task's callback must not clobber a newly-scheduled one.
-    task.add_done_callback(
-        lambda t: (
-            _pending_auto_approvals.pop(session_id, None)
-            if _pending_auto_approvals.get(session_id) is t
-            else None
-        )
-    )
-
 
 class DecomposeGoalTool(BaseTool):
     """Tool for decomposing an agent goal into sub-instructions."""
@@ -210,10 +29,11 @@ def name(self) -> str:
     @property
     def description(self) -> str:
         return (
-            "Break down an agent-building goal into logical sub-instructions. "
-            "Each step maps to one task (e.g. add a block, wire connections, "
-            "configure settings). ALWAYS call this before create_agent to show "
-            "the user your plan and get approval."
+            "Show the user your build plan as a step-by-step card before "
+            "constructing the agent. Each step maps to one task (e.g. add a "
+            "block, wire connections, configure settings). Display-only — "
+            "the build continues in the same turn without pausing for user "
+            "input."
         )
 
     @property
@@ -307,14 +127,10 @@ async def _execute(
                 )
             )
 
-        await _schedule_auto_approve(session_id, user_id, session)
-
         return TaskDecompositionResponse(
             message=f"Here's the plan to build your agent ({len(decomposition_steps)} steps):",
             goal=goal,
             steps=decomposition_steps,
             step_count=len(decomposition_steps),
-            requires_approval=True,
-            auto_approve_seconds=AUTO_APPROVE_CLIENT_SECONDS,
             session_id=session_id,
         )
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index 8cfecbc24ccd..b8421b400755 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -1,27 +1,11 @@
 """Unit tests for DecomposeGoalTool."""
 
-import asyncio
-from datetime import UTC, datetime
-from unittest.mock import AsyncMock, patch
-
 import pytest
 
-from backend.copilot.model import ChatMessage
-
-from . import decompose_goal as decompose_goal_module
 from ._test_data import make_session
-from .decompose_goal import (
-    AUTO_APPROVE_CLIENT_SECONDS,
-    DEFAULT_ACTION,
-    DecomposeGoalTool,
-    cancel_auto_approve,
-    needs_build_plan_approval,
-)
+from .decompose_goal import DEFAULT_ACTION, DecomposeGoalTool
 from .models import ErrorResponse, TaskDecompositionResponse
 
-# Captured before the autouse fixture stubs the real scheduler.
-_REAL_SCHEDULE_AUTO_APPROVE = decompose_goal_module._schedule_auto_approve
-
 _USER_ID = "test-user-decompose-goal"
 
 _VALID_STEPS = [
@@ -35,20 +19,6 @@
 ]
 
 
-@pytest.fixture(autouse=True)
-def _stub_auto_approve_scheduler():
-    """The existing happy-path tests don't have a database; stub the
-    fire-and-forget scheduler so they don't kick off real timers that try to
-    hit Redis/Postgres. Tests that exercise auto-approve override this with
-    their own patches inside the test body."""
-
-    async def _noop(*a, **kw):
-        pass
-
-    with patch.object(decompose_goal_module, "_schedule_auto_approve", _noop):
-        yield
-
-
 @pytest.fixture()
 def tool() -> DecomposeGoalTool:
     return DecomposeGoalTool()
@@ -77,7 +47,6 @@ async def test_happy_path(tool: DecomposeGoalTool, session):
     assert result.goal == "Build a news summarizer agent"
     assert len(result.steps) == 3
     assert result.step_count == 3
-    assert result.requires_approval is True
     assert result.steps[0].step_id == "step_1"
     assert result.steps[0].description == "Add input block"
     assert result.steps[1].block_name == "AI Text Generator"
@@ -96,20 +65,6 @@ async def test_step_count_matches_steps(tool: DecomposeGoalTool, session):
     assert result.step_count == len(result.steps)
 
 
-@pytest.mark.asyncio
-async def test_requires_approval_always_true(tool: DecomposeGoalTool, session):
-    """requires_approval must always be True regardless of kwargs."""
-    result = await tool._execute(
-        user_id=_USER_ID,
-        session=session,
-        goal="Build agent",
-        steps=_VALID_STEPS,
-        require_approval=False,  # should be ignored
-    )
-    assert isinstance(result, TaskDecompositionResponse)
-    assert result.requires_approval is True
-
-
 @pytest.mark.asyncio
 async def test_invalid_action_defaults_to_add_block(tool: DecomposeGoalTool, session):
     """Unknown action values are coerced to DEFAULT_ACTION."""
@@ -251,293 +206,3 @@ async def test_step_ids_are_sequential(tool: DecomposeGoalTool, session):
     assert isinstance(result, TaskDecompositionResponse)
     for i, step in enumerate(result.steps):
         assert step.step_id == f"step_{i + 1}"
-
-
-# ---------------------------------------------------------------------------
-# auto_approve_seconds field
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_response_includes_auto_approve_seconds(tool: DecomposeGoalTool, session):
-    """The response carries the countdown so the frontend has a single
-    source of truth instead of a hard-coded constant."""
-    result = await tool._execute(
-        user_id=_USER_ID,
-        session=session,
-        goal="Build agent",
-        steps=_VALID_STEPS,
-    )
-    assert isinstance(result, TaskDecompositionResponse)
-    assert result.auto_approve_seconds == AUTO_APPROVE_CLIENT_SECONDS
-
-
-@pytest.mark.asyncio
-async def test_response_includes_created_at(tool: DecomposeGoalTool, session):
-    """created_at must be stamped at execution time so the client can
-    compute remaining countdown when the user reopens the session."""
-    before = datetime.now(UTC)
-    result = await tool._execute(
-        user_id=_USER_ID,
-        session=session,
-        goal="Build agent",
-        steps=_VALID_STEPS,
-    )
-    after = datetime.now(UTC)
-
-    assert isinstance(result, TaskDecompositionResponse)
-    assert isinstance(result.created_at, datetime)
-    # Stamped during the call.
-    assert before <= result.created_at <= after
-
-
-# ---------------------------------------------------------------------------
-# needs_build_plan_approval — build-tool approval gate
-# ---------------------------------------------------------------------------
-
-
-def _decompose_tool_call() -> dict:
-    return {
-        "id": "call_1",
-        "type": "function",
-        "function": {"name": "decompose_goal", "arguments": "{}"},
-    }
-
-
-def test_needs_approval_blocks_when_no_decompose_in_session():
-    """LLM tries to build without calling decompose_goal at all."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
-    assert needs_build_plan_approval(session) is True
-
-
-def test_needs_approval_allows_any_user_response():
-    """Any user message after decompose_goal unblocks the gate."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
-    session.messages.append(
-        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
-    )
-    session.messages.append(ChatMessage(role="tool", content="{plan}"))
-    session.messages.append(ChatMessage(role="user", content="Sure"))
-    assert needs_build_plan_approval(session) is False
-
-
-def test_needs_approval_allows_explicit_approval():
-    """Explicit 'Approved' also passes (common from button/auto-approve)."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
-    session.messages.append(
-        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
-    )
-    session.messages.append(ChatMessage(role="tool", content="{plan}"))
-    session.messages.append(
-        ChatMessage(role="user", content="Approved. Please build the agent.")
-    )
-    assert needs_build_plan_approval(session) is False
-
-
-def test_needs_approval_allows_modification_request():
-    """User asking to modify the plan also passes — LLM decides what to do."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
-    session.messages.append(
-        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
-    )
-    session.messages.append(ChatMessage(role="tool", content="{plan}"))
-    session.messages.append(
-        ChatMessage(role="user", content="Change step 3 to use Gmail instead")
-    )
-    assert needs_build_plan_approval(session) is False
-
-
-def test_needs_approval_blocks_same_turn_decompose_and_build():
-    """LLM calls decompose_goal then immediately tries create_agent in the
-    same turn — no user message after decompose_goal yet."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
-    session.messages.append(
-        ChatMessage(role="assistant", content="", tool_calls=[_decompose_tool_call()])
-    )
-    session.messages.append(ChatMessage(role="tool", content="{plan}"))
-    assert needs_build_plan_approval(session) is True
-
-
-def test_needs_approval_blocks_without_prior_decompose():
-    """No decompose_goal in session → must decompose first."""
-    session = make_session(_USER_ID)
-    session.messages.append(ChatMessage(role="user", content="Build me an agent"))
-    assert needs_build_plan_approval(session) is True
-
-
-# ---------------------------------------------------------------------------
-# Server-side auto-approve task — uses run_copilot_turn_via_queue
-# ---------------------------------------------------------------------------
-
-
-class _FakeRedisNoCancelFlag:
-    """Stub Redis that reports no cancel flag and ignores writes."""
-
-    async def get(self, key):
-        return None
-
-    async def set(self, key, value, ex=None):
-        pass
-
-    async def delete(self, key):
-        pass
-
-
-def _stub_redis():
-    """Patch get_redis_async to return a fake Redis (no real connection)."""
-    return patch(
-        "backend.copilot.tools.decompose_goal.get_redis_async",
-        new=AsyncMock(return_value=_FakeRedisNoCancelFlag()),
-    )
-
-
-@pytest.mark.asyncio
-async def test_auto_approve_dispatches_via_queue_helper():
-    """_run_auto_approve should delegate to run_copilot_turn_via_queue."""
-    fake_dispatch = AsyncMock(return_value=("completed", None))
-
-    with (
-        _stub_redis(),
-        patch(
-            "backend.copilot.sdk.session_waiter.run_copilot_turn_via_queue",
-            new=fake_dispatch,
-        ),
-        patch(
-            "backend.copilot.tools.decompose_goal.AUTO_APPROVE_SERVER_SECONDS",
-            0,
-        ),
-    ):
-        await decompose_goal_module._run_auto_approve("session-idle", _USER_ID)
-
-    fake_dispatch.assert_awaited_once()
-    call_kwargs = fake_dispatch.await_args.kwargs
-    assert call_kwargs["session_id"] == "session-idle"
-    assert call_kwargs["message"] == "Approved. Please build the agent."
-    assert call_kwargs["timeout"] == 0
-    assert call_kwargs["tool_name"] == "decompose_goal_auto_approve"
-
-
-@pytest.mark.asyncio
-async def test_auto_approve_swallows_unexpected_errors():
-    """A failure inside the task must never propagate."""
-
-    async def boom(*args, **kwargs):
-        raise RuntimeError("kaboom")
-
-    with (
-        _stub_redis(),
-        patch(
-            "backend.copilot.sdk.session_waiter.run_copilot_turn_via_queue",
-            new=boom,
-        ),
-        patch(
-            "backend.copilot.tools.decompose_goal.AUTO_APPROVE_SERVER_SECONDS",
-            0,
-        ),
-    ):
-        await decompose_goal_module._run_auto_approve("session-error", None)
-
-
-@pytest.mark.asyncio
-async def test_schedule_auto_approve_creates_task(monkeypatch):
-    """_schedule_auto_approve should add a task to the tracking dict."""
-    monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 0)
-    fake_run = AsyncMock()
-    monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
-    monkeypatch.setattr(
-        decompose_goal_module,
-        "get_redis_async",
-        AsyncMock(return_value=_FakeRedisNoCancelFlag()),
-    )
-
-    session = make_session(_USER_ID)
-
-    await _REAL_SCHEDULE_AUTO_APPROVE(
-        session_id="session-schedule",
-        user_id=_USER_ID,
-        session=session,
-    )
-
-    await asyncio.sleep(0)
-    while decompose_goal_module._pending_auto_approvals:
-        await asyncio.sleep(0)
-
-    fake_run.assert_awaited_once_with("session-schedule", _USER_ID)
-
-
-@pytest.mark.asyncio
-async def test_schedule_auto_approve_no_op_without_session_id():
-    """Empty session id should be a no-op (defensive)."""
-    session = make_session(_USER_ID)
-    await decompose_goal_module._schedule_auto_approve(
-        session_id=None, user_id=_USER_ID, session=session
-    )
-    assert len(decompose_goal_module._pending_auto_approvals) == 0
-
-
-# ---------------------------------------------------------------------------
-# cancel_auto_approve
-# ---------------------------------------------------------------------------
-
-
-@pytest.mark.asyncio
-async def test_cancel_auto_approve_sets_redis_flag_and_cancels_task(monkeypatch):
-    """cancel_auto_approve should set a Redis cancel flag AND cancel the
-    in-process task. Returns True always (Redis flag is authoritative)."""
-    monkeypatch.setattr(decompose_goal_module, "AUTO_APPROVE_SERVER_SECONDS", 999)
-    fake_run = AsyncMock()
-    monkeypatch.setattr(decompose_goal_module, "_run_auto_approve", fake_run)
-
-    captured_redis_calls: list[tuple] = []
-
-    class FakeRedis:
-        async def set(self, key, value, ex=None):
-            captured_redis_calls.append(("set", key, value, ex))
-
-        async def get(self, key):
-            return None
-
-        async def delete(self, key):
-            pass
-
-    monkeypatch.setattr(
-        decompose_goal_module, "get_redis_async", AsyncMock(return_value=FakeRedis())
-    )
-
-    session = make_session(_USER_ID)
-    await _REAL_SCHEDULE_AUTO_APPROVE(
-        session_id="session-cancel-test",
-        user_id=_USER_ID,
-        session=session,
-    )
-
-    assert "session-cancel-test" in decompose_goal_module._pending_auto_approvals
-    result = await cancel_auto_approve("session-cancel-test")
-    assert result is True
-    assert "session-cancel-test" not in decompose_goal_module._pending_auto_approvals
-    assert len(captured_redis_calls) == 1
-    assert captured_redis_calls[0][0] == "set"
-    assert "session-cancel-test" in captured_redis_calls[0][1]
-
-
-@pytest.mark.asyncio
-async def test_cancel_auto_approve_returns_true_even_without_in_process_task(
-    monkeypatch,
-):
-    """Even if no in-process task exists (e.g. task is in another process),
-    cancel_auto_approve should still set the Redis flag and return True."""
-
-    class FakeRedis:
-        async def set(self, key, value, ex=None):
-            pass
-
-    monkeypatch.setattr(
-        decompose_goal_module, "get_redis_async", AsyncMock(return_value=FakeRedis())
-    )
-    result = await cancel_auto_approve("nonexistent-session")
-    assert result is True
diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.py
index 51172288dd09..078ef9ab774e 100644
--- a/autogpt_platform/backend/backend/copilot/tools/models.py
+++ b/autogpt_platform/backend/backend/copilot/tools/models.py
@@ -1,6 +1,6 @@
 """Pydantic models for tool responses."""
 
-from datetime import UTC, datetime
+from datetime import datetime
 from enum import Enum
 from typing import Any, Literal
 
@@ -845,24 +845,6 @@ class TaskDecompositionResponse(ToolResponseBase):
     step_count: int = Field(
         default=0, description="Number of steps (auto-derived from steps list)"
     )
-    requires_approval: bool = True
-    auto_approve_seconds: int = Field(
-        default=60,
-        description=(
-            "Seconds the client should count down before auto-approving. "
-            "Kept in sync with the server-side fallback timer, which runs a "
-            "grace period longer to absorb network latency."
-        ),
-    )
-    created_at: datetime = Field(
-        default_factory=lambda: datetime.now(UTC),
-        description=(
-            "UTC timestamp when the tool returned. The client uses this with "
-            "auto_approve_seconds to compute the correct remaining countdown "
-            "when the user reopens the session — so the timer reflects real "
-            "elapsed time instead of restarting from zero."
-        ),
-    )
 
     @model_validator(mode="after")
     def sync_step_count(self) -> "TaskDecompositionResponse":
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
index 4d769ba9a416..2fe7be8ee5a3 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx
@@ -55,8 +55,6 @@ function renderSegments(
   segments: RenderSegment[],
   messageID: string,
   onRetry?: () => void,
-  isLastMessage?: boolean,
-  isMessageStreaming?: boolean,
 ): React.ReactNode[] {
   return segments.map((seg, segIdx) => {
     if (seg.kind === "collapsed-group") {
@@ -69,8 +67,6 @@ function renderSegments(
         messageID={messageID}
         partIndex={seg.index}
         onRetry={onRetry}
-        isLastMessage={isLastMessage}
-        isMessageStreaming={isMessageStreaming}
       />
     );
   });
@@ -448,8 +444,6 @@ export function ChatMessagesContainer({
                       responseSegments,
                       message.id,
                       isLastAssistant ? onRetry : undefined,
-                      isLastAssistant,
-                      isCurrentlyStreaming,
                     )
                   : message.parts.map((part, i) => (
                       <MessagePartRenderer
@@ -458,8 +452,6 @@ export function ChatMessagesContainer({
                         messageID={message.id}
                         partIndex={i}
                         onRetry={isLastAssistant ? onRetry : undefined}
-                        isLastMessage={isLastAssistant}
-                        isMessageStreaming={isCurrentlyStreaming}
                       />
                     ))}
                 {isLastInTurn && !isCurrentlyStreaming && (
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index 552b83f198f2..97bd19cc92d8 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -56,7 +56,6 @@ describe("isInteractiveToolPart", () => {
       goal: "Build agent",
       steps: [],
       step_count: 0,
-      requires_approval: true,
     });
     expect(isInteractiveToolPart(part)).toBe(true);
   });
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
index 576c92587126..15061d616b26 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/MessagePartRenderer.tsx
@@ -95,8 +95,6 @@ interface Props {
   messageID: string;
   partIndex: number;
   onRetry?: () => void;
-  isLastMessage?: boolean;
-  isMessageStreaming?: boolean;
 }
 
 export function MessagePartRenderer({
@@ -104,8 +102,6 @@ export function MessagePartRenderer({
   messageID,
   partIndex,
   onRetry,
-  isLastMessage,
-  isMessageStreaming,
 }: Props) {
   const key = `${messageID}-${partIndex}`;
 
@@ -186,14 +182,7 @@ export function MessagePartRenderer({
     case "tool-schedule_agent":
       return <RunAgentTool key={key} part={part as ToolUIPart} />;
     case "tool-decompose_goal":
-      return (
-        <DecomposeGoalTool
-          key={key}
-          part={part as ToolUIPart}
-          isLastMessage={isLastMessage}
-          isMessageStreaming={isMessageStreaming}
-        />
-      );
+      return <DecomposeGoalTool key={key} part={part as ToolUIPart} />;
     case "tool-create_agent":
       return <CreateAgentTool key={key} part={part as ToolUIPart} />;
     case "tool-edit_agent":
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
index 6f14c8f42055..7f89ea7ebc3f 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/DecomposeGoal.tsx
@@ -1,15 +1,6 @@
 "use client";
 
-import { postV2CancelAutoApproveTask } from "@/app/api/__generated__/endpoints/chat/chat";
-import { Button } from "@/components/atoms/Button/Button";
-import {
-  CheckIcon,
-  PencilSimpleIcon,
-  PlusIcon,
-  TrashIcon,
-} from "@phosphor-icons/react";
 import type { ToolUIPart } from "ai";
-import { useEffect, useRef, useState } from "react";
 import { useCopilotChatActions } from "../../components/CopilotChatActionsProvider/useCopilotChatActions";
 import { MorphingTextAnimation } from "../../components/MorphingTextAnimation/MorphingTextAnimation";
 import {
@@ -21,40 +12,18 @@ import { ToolErrorCard } from "../../components/ToolErrorCard/ToolErrorCard";
 import { StepItem } from "./components/StepItem";
 import {
   AccordionIcon,
-  computeRemainingSeconds,
   getAnimationText,
   getDecomposeGoalOutput,
   isDecompositionOutput,
   isErrorOutput,
-  FALLBACK_COUNTDOWN_SECONDS,
   ToolIcon,
 } from "./helpers";
 
-const RADIUS = 15;
-const CIRCUMFERENCE = 2 * Math.PI * RADIUS;
-
-interface EditableStep {
-  step_id: string;
-  description: string;
-  action: string;
-  block_name?: string | null;
-  status: string;
-}
-
 interface Props {
   part: ToolUIPart;
-  isLastMessage?: boolean;
-  // True while the parent assistant message is still streaming. We disable
-  // Approve/Modify in this window because the chat session is locked to
-  // the in-flight turn — sending a new user message would fail.
-  isMessageStreaming?: boolean;
 }
 
-export function DecomposeGoalTool({
-  part,
-  isLastMessage,
-  isMessageStreaming,
-}: Props) {
+export function DecomposeGoalTool({ part }: Props) {
   const text = getAnimationText(part);
   const { onSend } = useCopilotChatActions();
 
@@ -66,165 +35,6 @@ export function DecomposeGoalTool({
     part.state === "output-error" || (!!output && isErrorOutput(output));
   const isPending = !output && !isError;
 
-  const showActions =
-    !!isLastMessage &&
-    !!output &&
-    isDecompositionOutput(output) &&
-    output.requires_approval;
-
-  // The Approve/Modify buttons are visible (so the user knows what's
-  // coming) but click-disabled while the assistant is still streaming
-  // its summary text after the tool call. The countdown ring keeps
-  // ticking so it stays in sync with the server-side timer.
-  const actionsEnabled = showActions && !isMessageStreaming;
-
-  // Authoritative countdown comes from the backend tool response so the
-  // server-side fallback timer and the client are guaranteed to agree.
-  const countdownSeconds =
-    (output && isDecompositionOutput(output) && output.auto_approve_seconds) ||
-    FALLBACK_COUNTDOWN_SECONDS;
-
-  // Lazy initializer: runs once on mount and seeds remaining time from the
-  // backend ``created_at`` so reopening a session resumes the countdown
-  // instead of restarting it.
-  const [secondsLeft, setSecondsLeft] = useState(() =>
-    computeRemainingSeconds(output, FALLBACK_COUNTDOWN_SECONDS),
-  );
-  // timerActive becomes false when the user clicks Modify — stops countdown and auto-approve.
-  const [timerActive, setTimerActive] = useState(true);
-  const [isEditing, setIsEditing] = useState(false);
-  const [editableSteps, setEditableSteps] = useState<EditableStep[]>([]);
-
-  // True when secondsLeft started at 0 because the server-stamped deadline
-  // had already elapsed before this mount. Prevents the auto-approve effect
-  // from firing on remount with stale cache — the server handles that case.
-  // Without this, re-entering after the deadline sends a duplicate "Approved".
-  const wasInitiallyPastDeadlineRef = useRef(
-    secondsLeft === 0 &&
-      !!output &&
-      isDecompositionOutput(output) &&
-      !!output.created_at,
-  );
-
-  const approvedRef = useRef(false);
-  const onSendRef = useRef(onSend);
-  const isEditingRef = useRef(isEditing);
-  const editableStepsRef = useRef(editableSteps);
-  onSendRef.current = onSend;
-  isEditingRef.current = isEditing;
-  editableStepsRef.current = editableSteps;
-
-  function buildMessage() {
-    if (isEditingRef.current && editableStepsRef.current.length > 0) {
-      const filledSteps = editableStepsRef.current.filter((s) =>
-        s.description.trim(),
-      );
-      if (filledSteps.length > 0) {
-        const list = filledSteps
-          .map((s, i) => `${i + 1}. ${s.description}`)
-          .join("; ");
-        return `Approved with modifications. Please build the agent following these steps: ${list}`;
-      }
-    }
-    return "Approved. Please build the agent.";
-  }
-
-  function approve() {
-    if (approvedRef.current) return;
-    approvedRef.current = true;
-    setIsEditing(false);
-    onSendRef.current(buildMessage());
-  }
-
-  function handleModify() {
-    if (approvedRef.current) return;
-    if (!output || !isDecompositionOutput(output)) return;
-    setTimerActive(false);
-    setIsEditing(true);
-    setEditableSteps(
-      output.steps.map((s) => ({ ...s, status: s.status ?? "pending" })),
-    );
-
-    // Cancel the server-side auto-approve timer so it doesn't fire the
-    // default "Approved" message while the user is editing steps.
-    if (output.session_id) {
-      postV2CancelAutoApproveTask(output.session_id).catch(() => {
-        // Best-effort — if the timer already fired or the request fails,
-        // the predicate check will still prevent a duplicate.
-      });
-    }
-  }
-
-  function handleStepChange(index: number, description: string) {
-    setEditableSteps((prev) =>
-      prev.map((s, i) => (i === index ? { ...s, description } : s)),
-    );
-  }
-
-  function handleStepDelete(index: number) {
-    setEditableSteps((prev) => prev.filter((_, i) => i !== index));
-  }
-
-  // Insert a blank step after the given index (-1 = prepend).
-  function handleStepInsert(afterIndex: number) {
-    setEditableSteps((prev) => {
-      const next = [...prev];
-      next.splice(afterIndex + 1, 0, {
-        step_id: `step_new_${crypto.randomUUID()}`,
-        description: "",
-        action: "add_block",
-        status: "pending",
-      });
-      return next;
-    });
-  }
-
-  // If a new message arrives while editing, exit edit mode so the user is not stuck.
-  useEffect(() => {
-    if (!showActions && isEditing) {
-      setIsEditing(false);
-    }
-  }, [showActions, isEditing]);
-
-  // The timer only ticks once the turn is fully finished (actionsEnabled
-  // includes !isMessageStreaming). This gives the user the full countdown
-  // duration to review the plan after all streaming completes — not from
-  // when the tool returned (which would eat streaming time into the review
-  // window). For session re-entry, the lazy initializer already seeds
-  // secondsLeft from created_at, so the timer resumes correctly.
-  useEffect(() => {
-    if (!actionsEnabled || !timerActive) return;
-    const interval = setInterval(() => {
-      setSecondsLeft((s) => Math.max(0, s - 1));
-    }, 1000);
-    return () => clearInterval(interval);
-  }, [actionsEnabled, timerActive, part.toolCallId]);
-
-  // Auto-approve when countdown reaches 0. The client fires at 60s; the
-  // server fires 5s later as a fallback for the "user closed the tab" case.
-  // When the client IS present, its approve() creates the SSE subscription
-  // so the user sees the build in real-time. The server's predicate then
-  // sees the user's message and skips — no duplicate.
-  // approve() is stable via approvedRef — safe to omit from deps.
-  useEffect(() => {
-    if (
-      secondsLeft === 0 &&
-      timerActive &&
-      actionsEnabled &&
-      !wasInitiallyPastDeadlineRef.current
-    ) {
-      approve();
-    }
-  }, [secondsLeft, timerActive, actionsEnabled]);
-
-  const progress = secondsLeft / countdownSeconds;
-  const dashOffset = CIRCUMFERENCE * (1 - progress);
-  const stepCount = isEditing
-    ? editableSteps.length
-    : output && isDecompositionOutput(output)
-      ? output.step_count
-      : 0;
-
   return (
     <div className="py-2">
       {isPending && (
@@ -255,7 +65,7 @@ export function DecomposeGoalTool({
       {output && isDecompositionOutput(output) && (
         <ToolAccordion
           icon={<AccordionIcon />}
-          title={`Build Plan — ${stepCount} steps`}
+          title={`Build Plan — ${output.step_count} steps`}
           description={output.goal}
           defaultExpanded
         >
@@ -263,164 +73,21 @@ export function DecomposeGoalTool({
             <ContentMessage>{output.message}</ContentMessage>
 
             <div className="rounded-lg border border-border bg-card p-3">
-              {isEditing ? (
-                <div className="flex flex-col">
-                  {/* Insert before the first step */}
-                  <InsertButton onClick={() => handleStepInsert(-1)} />
-
-                  {editableSteps.map((step, i) => (
-                    <div key={step.step_id} className="flex flex-col">
-                      <div className="flex items-start gap-2 py-1">
-                        <span className="w-5 shrink-0 pt-1 text-xs text-muted-foreground">
-                          {i + 1}.
-                        </span>
-                        <textarea
-                          ref={(el) => {
-                            if (el) {
-                              el.style.height = "auto";
-                              el.style.height = `${el.scrollHeight}px`;
-                            }
-                          }}
-                          value={step.description}
-                          onChange={(e) => handleStepChange(i, e.target.value)}
-                          rows={1}
-                          className="flex-1 resize-none overflow-hidden rounded border border-border px-2 py-1 text-sm focus:border-neutral-400 focus:outline-none"
-                          placeholder="Step description"
-                        />
-                        <button
-                          type="button"
-                          onClick={() => handleStepDelete(i)}
-                          className="mt-1 text-muted-foreground hover:text-red-500"
-                          aria-label="Remove step"
-                        >
-                          <TrashIcon size={14} />
-                        </button>
-                      </div>
-                      {/* Insert after each step */}
-                      <InsertButton onClick={() => handleStepInsert(i)} />
-                    </div>
-                  ))}
-                </div>
-              ) : (
-                <div className="space-y-0.5">
-                  {output.steps.map((step, i) => (
-                    <StepItem
-                      key={step.step_id}
-                      index={i}
-                      description={step.description}
-                      blockName={step.block_name}
-                      status={step.status ?? "pending"}
-                    />
-                  ))}
-                </div>
-              )}
-            </div>
-
-            {showActions && (
-              <div className="flex items-center gap-2 pt-1">
-                {isEditing ? (
-                  <Button
-                    variant="primary"
-                    onClick={approve}
-                    disabled={!actionsEnabled}
-                  >
-                    <span className="inline-flex items-center gap-1.5">
-                      <CheckIcon size={14} weight="bold" />
-                      Approve
-                    </span>
-                  </Button>
-                ) : (
-                  <>
-                    {/* Primary CTA — encourages user to run the agent */}
-                    <Button
-                      variant="primary"
-                      size="small"
-                      onClick={approve}
-                      disabled={!actionsEnabled}
-                    >
-                      <span className="group/label inline-flex items-center gap-2">
-                        <span className="inline-flex items-center gap-1.5 group-hover/label:hidden">
-                          Starting in
-                          <span className="relative inline-flex h-6 w-6 items-center justify-center">
-                            <svg
-                              width="24"
-                              height="24"
-                              viewBox="0 0 34 34"
-                              className="absolute -rotate-90"
-                            >
-                              <circle
-                                cx="17"
-                                cy="17"
-                                r={RADIUS}
-                                fill="none"
-                                stroke="currentColor"
-                                strokeWidth="2"
-                                className="text-white/30"
-                              />
-                              <circle
-                                cx="17"
-                                cy="17"
-                                r={RADIUS}
-                                fill="none"
-                                stroke="currentColor"
-                                strokeWidth="2"
-                                strokeLinecap="round"
-                                strokeDasharray={CIRCUMFERENCE}
-                                strokeDashoffset={dashOffset}
-                                className="text-white transition-[stroke-dashoffset] duration-1000 ease-linear"
-                              />
-                            </svg>
-                            <span className="relative z-10 text-[11px] font-semibold tabular-nums text-white">
-                              {secondsLeft}
-                            </span>
-                          </span>
-                        </span>
-                        <span className="hidden group-hover/label:inline">
-                          Start now
-                        </span>
-                      </span>
-                    </Button>
-                    <Button
-                      variant="ghost"
-                      size="small"
-                      onClick={handleModify}
-                      disabled={!actionsEnabled}
-                    >
-                      <span className="inline-flex items-center gap-1.5">
-                        <PencilSimpleIcon size={14} weight="bold" />
-                        Modify
-                      </span>
-                    </Button>
-                  </>
-                )}
+              <div className="space-y-0.5">
+                {output.steps.map((step, i) => (
+                  <StepItem
+                    key={step.step_id}
+                    index={i}
+                    description={step.description}
+                    blockName={step.block_name}
+                    status={step.status ?? "pending"}
+                  />
+                ))}
               </div>
-            )}
-
-            {output.requires_approval && !showActions && (
-              <ContentMessage>
-                Review the plan above and approve to start building.
-              </ContentMessage>
-            )}
+            </div>
           </ContentGrid>
         </ToolAccordion>
       )}
     </div>
   );
 }
-
-function InsertButton({ onClick }: { onClick: () => void }) {
-  return (
-    <div className="group flex items-center gap-1 py-0.5">
-      <div className="h-px flex-1 bg-border group-hover:bg-neutral-300" />
-      <button
-        type="button"
-        onClick={onClick}
-        className="flex items-center gap-0.5 rounded px-1 text-xs text-muted-foreground hover:text-foreground focus:outline-none"
-        aria-label="Insert step here"
-      >
-        <PlusIcon size={10} weight="bold" />
-      </button>
-      <div className="h-px flex-1 bg-border group-hover:bg-neutral-300" />
-    </div>
-  );
-}
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
index e0fbd852d0a5..09a4178d06dc 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
@@ -3,7 +3,6 @@ import {
   fireEvent,
   render,
   screen,
-  waitFor,
 } from "@/tests/integrations/test-utils";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { DecomposeGoalTool } from "../DecomposeGoal";
@@ -17,10 +16,6 @@ vi.mock(
   }),
 );
 
-vi.mock("@/app/api/__generated__/endpoints/chat/chat", () => ({
-  postV2CancelAutoApproveTask: vi.fn(() => Promise.resolve()),
-}));
-
 const STEPS = [
   {
     step_id: "step_1",
@@ -51,9 +46,6 @@ const DECOMPOSITION: TaskDecompositionOutput = {
   goal: "Build a news summarizer",
   steps: STEPS,
   step_count: 3,
-  requires_approval: true,
-  auto_approve_seconds: 60,
-  created_at: new Date().toISOString(),
   session_id: "test-session-1",
 };
 
@@ -84,33 +76,18 @@ describe("DecomposeGoalTool", () => {
   });
 
   it("renders analyzing animation during input-streaming", () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("input-streaming") as any}
-        isLastMessage
-      />,
-    );
+    render(<DecomposeGoalTool part={makePart("input-streaming") as any} />);
     expect(screen.getByText(/A/)).toBeDefined();
   });
 
   it("renders error card when state is output-error", () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-error") as any}
-        isLastMessage
-      />,
-    );
+    render(<DecomposeGoalTool part={makePart("output-error") as any} />);
     expect(screen.getByText(/Failed to analyze the goal/i)).toBeDefined();
     expect(screen.getByText("Try again")).toBeDefined();
   });
 
   it("sends retry message when Try again is clicked on error", () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-error") as any}
-        isLastMessage
-      />,
-    );
+    render(<DecomposeGoalTool part={makePart("output-error") as any} />);
     fireEvent.click(screen.getByText("Try again"));
     expect(mockOnSend).toHaveBeenCalledWith(
       "Please try decomposing the goal again.",
@@ -126,17 +103,15 @@ describe("DecomposeGoalTool", () => {
     render(
       <DecomposeGoalTool
         part={makePart("output-available", errorOutput) as any}
-        isLastMessage
       />,
     );
     expect(screen.getByText("Please provide at least one step.")).toBeDefined();
   });
 
-  it("renders the build plan accordion with steps", () => {
+  it("renders the build plan accordion with steps as a read-only list", () => {
     render(
       <DecomposeGoalTool
         part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
       />,
     );
     expect(screen.getByText(/Build Plan — 3 steps/)).toBeDefined();
@@ -151,254 +126,37 @@ describe("DecomposeGoalTool", () => {
     render(
       <DecomposeGoalTool
         part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
       />,
     );
     expect(screen.getByText("AI Text Generator")).toBeDefined();
   });
 
-  it("shows approve and modify buttons when requires_approval and isLastMessage", () => {
+  it("does not render approve, modify, or edit controls", () => {
     render(
       <DecomposeGoalTool
         part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-    expect(screen.getByText("Modify")).toBeDefined();
-    expect(screen.getByText(/Starting in/)).toBeDefined();
-  });
-
-  it("hides action buttons when isLastMessage is false", () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage={false}
       />,
     );
     expect(screen.queryByText("Modify")).toBeNull();
-    expect(screen.getByText(/Review the plan above and approve/)).toBeDefined();
+    expect(screen.queryByText("Approve")).toBeNull();
+    expect(screen.queryByText(/Starting in/)).toBeNull();
+    expect(screen.queryByPlaceholderText("Step description")).toBeNull();
+    expect(screen.queryByLabelText("Remove step")).toBeNull();
+    expect(screen.queryByLabelText("Insert step here")).toBeNull();
   });
 
-  it("hides action buttons when requires_approval is false", () => {
-    const noApproval = { ...DECOMPOSITION, requires_approval: false };
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", noApproval) as any}
-        isLastMessage
-      />,
-    );
-    expect(screen.queryByText("Modify")).toBeNull();
-  });
-
-  it("disables buttons while message is still streaming", () => {
+  it("does not call onSend when the plan card renders", () => {
     render(
       <DecomposeGoalTool
         part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-        isMessageStreaming
       />,
     );
-    const modifyBtn = screen.getByText("Modify").closest("button");
-    expect(modifyBtn?.disabled).toBe(true);
-  });
-
-  it("sends approval message when approve button is clicked", async () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    const startBtn = screen.getByText(/Starting in/).closest("button");
-    expect(startBtn).toBeDefined();
-    fireEvent.click(startBtn!);
-
-    await waitFor(() => {
-      expect(mockOnSend).toHaveBeenCalledWith(
-        "Approved. Please build the agent.",
-      );
-    });
-  });
-
-  it("does not send duplicate approval on second click", async () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    const startBtn = screen.getByText(/Starting in/).closest("button");
-    fireEvent.click(startBtn!);
-    fireEvent.click(startBtn!);
-
-    await waitFor(() => {
-      expect(mockOnSend).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it("enters edit mode when Modify is clicked", async () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    fireEvent.click(screen.getByText("Modify"));
-
-    await waitFor(() => {
-      const textareas = screen.getAllByPlaceholderText("Step description");
-      expect(textareas.length).toBe(3);
-    });
-  });
-
-  it("cancels auto-approve on the server when Modify is clicked", async () => {
-    const { postV2CancelAutoApproveTask } = await import(
-      "@/app/api/__generated__/endpoints/chat/chat"
-    );
-
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    fireEvent.click(screen.getByText("Modify"));
-
-    await waitFor(() => {
-      expect(postV2CancelAutoApproveTask).toHaveBeenCalledWith(
-        "test-session-1",
-      );
-    });
-  });
-
-  it("allows editing step descriptions in edit mode", async () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    fireEvent.click(screen.getByText("Modify"));
-
-    await waitFor(() => {
-      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
-    });
-
-    const textareas = screen.getAllByPlaceholderText("Step description");
-    fireEvent.change(textareas[0], {
-      target: { value: "Fetch RSS feed" },
-    });
-
-    expect(
-      (
-        screen.getAllByPlaceholderText(
-          "Step description",
-        )[0] as HTMLTextAreaElement
-      ).value,
-    ).toBe("Fetch RSS feed");
-  });
-
-  it("allows deleting steps in edit mode", async () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    fireEvent.click(screen.getByText("Modify"));
-
-    await waitFor(() => {
-      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
-    });
-
-    const removeButtons = screen.getAllByLabelText("Remove step");
-    fireEvent.click(removeButtons[0]);
-
-    await waitFor(() => {
-      expect(screen.getAllByPlaceholderText("Step description").length).toBe(2);
-    });
-  });
-
-  it("allows inserting new steps in edit mode", async () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    fireEvent.click(screen.getByText("Modify"));
-
-    await waitFor(() => {
-      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
-    });
-
-    const insertButtons = screen.getAllByLabelText("Insert step here");
-    fireEvent.click(insertButtons[0]);
-
-    await waitFor(() => {
-      expect(screen.getAllByPlaceholderText("Step description").length).toBe(4);
-    });
-  });
-
-  it("sends modified steps message when approve is clicked in edit mode", async () => {
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    fireEvent.click(screen.getByText("Modify"));
-
-    await waitFor(() => {
-      expect(screen.getAllByPlaceholderText("Step description").length).toBe(3);
-    });
-
-    const textareas = screen.getAllByPlaceholderText("Step description");
-    fireEvent.change(textareas[0], {
-      target: { value: "Fetch RSS feed" },
-    });
-
-    fireEvent.click(screen.getByText("Approve"));
-
-    await waitFor(() => {
-      expect(mockOnSend).toHaveBeenCalledWith(
-        expect.stringContaining("Approved with modifications"),
-      );
-      expect(mockOnSend).toHaveBeenCalledWith(
-        expect.stringContaining("Fetch RSS feed"),
-      );
-    });
-  });
-
-  it("renders countdown timer in the approve button", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date(DECOMPOSITION.created_at!));
-
-    render(
-      <DecomposeGoalTool
-        part={makePart("output-available", DECOMPOSITION) as any}
-        isLastMessage
-      />,
-    );
-
-    expect(screen.getByText("60")).toBeDefined();
-    vi.useRealTimers();
+    expect(mockOnSend).not.toHaveBeenCalled();
   });
 
   it("renders nothing pending when output is not yet available", () => {
     const { container } = render(
-      <DecomposeGoalTool
-        part={makePart("input-available") as any}
-        isLastMessage
-      />,
+      <DecomposeGoalTool part={makePart("input-available") as any} />,
     );
     expect(container.querySelector(".py-2")).toBeDefined();
   });
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
index fc26c90161e4..129e26e27197 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
@@ -4,10 +4,8 @@
  * Covers: parseOutput / getDecomposeGoalOutput, type guards, getAnimationText
  */
 
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it } from "vitest";
 import {
-  computeRemainingSeconds,
-  FALLBACK_COUNTDOWN_SECONDS,
   getAnimationText,
   getDecomposeGoalOutput,
   isDecompositionOutput,
@@ -49,7 +47,6 @@ const DECOMPOSITION: TaskDecompositionOutput = {
     },
   ],
   step_count: 3,
-  requires_approval: true,
 };
 
 const ERROR_OUTPUT: DecomposeErrorOutput = {
@@ -208,88 +205,3 @@ describe("getAnimationText", () => {
     expect(text.toLowerCase()).toContain("analyzing");
   });
 });
-
-// ---------------------------------------------------------------------------
-// computeRemainingSeconds
-// ---------------------------------------------------------------------------
-
-const DECOMPOSITION_BASE: TaskDecompositionOutput = {
-  type: "task_decomposition",
-  message: "Plan",
-  goal: "Build agent",
-  steps: [{ step_id: "s1", description: "Step 1", action: "add_block" }],
-  step_count: 1,
-  requires_approval: true,
-  auto_approve_seconds: 60,
-  created_at: new Date().toISOString(),
-};
-
-describe("computeRemainingSeconds", () => {
-  it("returns fallback when output is null", () => {
-    expect(computeRemainingSeconds(null, 60)).toBe(60);
-  });
-
-  it("returns fallback when output is an error", () => {
-    const err: DecomposeErrorOutput = { type: "error", error: "oops" };
-    expect(computeRemainingSeconds(err, 60)).toBe(60);
-  });
-
-  it("returns auto_approve_seconds when created_at is missing", () => {
-    const noTimestamp = { ...DECOMPOSITION_BASE, created_at: undefined };
-    expect(computeRemainingSeconds(noTimestamp, 99)).toBe(60);
-  });
-
-  it("returns auto_approve_seconds when created_at is unparseable", () => {
-    const badTimestamp = { ...DECOMPOSITION_BASE, created_at: "not-a-date" };
-    expect(computeRemainingSeconds(badTimestamp, 99)).toBe(60);
-  });
-
-  it("returns correct remaining seconds for a recent timestamp", () => {
-    vi.useFakeTimers();
-    const now = new Date("2026-01-01T00:00:30Z");
-    vi.setSystemTime(now);
-    const output = {
-      ...DECOMPOSITION_BASE,
-      created_at: "2026-01-01T00:00:00Z",
-    };
-    // 30s elapsed → 60 - 30 = 30
-    expect(computeRemainingSeconds(output, 60)).toBe(30);
-    vi.useRealTimers();
-  });
-
-  it("clamps to 0 when deadline has passed", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-01-01T00:02:00Z"));
-    const output = {
-      ...DECOMPOSITION_BASE,
-      created_at: "2026-01-01T00:00:00Z",
-    };
-    expect(computeRemainingSeconds(output, 60)).toBe(0);
-    vi.useRealTimers();
-  });
-
-  it("clamps to total when client clock is ahead (future timestamp)", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-01-01T00:00:00Z"));
-    const output = {
-      ...DECOMPOSITION_BASE,
-      created_at: "2026-01-01T00:00:10Z",
-    };
-    // elapsed = -10 → total - (-10) = 70, clamped to 60
-    expect(computeRemainingSeconds(output, 60)).toBe(60);
-    vi.useRealTimers();
-  });
-
-  it("uses fallback when auto_approve_seconds is missing", () => {
-    const noAutoApprove = {
-      ...DECOMPOSITION_BASE,
-      auto_approve_seconds: undefined,
-      created_at: undefined,
-    };
-    expect(computeRemainingSeconds(noAutoApprove, 42)).toBe(42);
-  });
-
-  it("exports FALLBACK_COUNTDOWN_SECONDS as 60", () => {
-    expect(FALLBACK_COUNTDOWN_SECONDS).toBe(60);
-  });
-});
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
index f8b3cd23203b..5249558182a7 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -15,11 +15,6 @@ import { ScaleLoader } from "../../components/ScaleLoader/ScaleLoader";
 // Re-export generated step type for consumers that need it.
 export type DecompositionStep = DecompositionStepModel;
 
-// Hand-rolled because the tool output is parsed from opaque JSON (not through
-// the generated API client), so the runtime shape differs from the generated
-// TaskDecompositionResponse — notably ``created_at`` is an ISO 8601 string at
-// runtime, whereas the generated type declares ``Date``. Keep fields in sync
-// with backend ``TaskDecompositionResponse`` in tools/models.py.
 export interface TaskDecompositionOutput {
   type: string;
   message: string;
@@ -27,9 +22,6 @@ export interface TaskDecompositionOutput {
   goal: string;
   steps: DecompositionStep[];
   step_count: number;
-  requires_approval: boolean;
-  auto_approve_seconds?: number;
-  created_at?: string;
 }
 
 export interface DecomposeErrorOutput {
@@ -42,33 +34,6 @@ export type DecomposeGoalOutput =
   | TaskDecompositionOutput
   | DecomposeErrorOutput;
 
-// Fallback used only if the backend response omits auto_approve_seconds
-// (older sessions). The authoritative value comes from the tool output.
-export const FALLBACK_COUNTDOWN_SECONDS = 60;
-
-/**
- * Compute remaining countdown seconds, deriving elapsed time from the
- * backend-stamped ``created_at`` so the timer reflects real elapsed time
- * when the user reopens the session — instead of restarting from full.
- *
- * Falls back to the full countdown when ``created_at`` is missing (older
- * sessions stored before this field existed) or unparseable. Clamps to
- * ``[0, total]`` to defend against client clock skew producing future
- * timestamps.
- */
-export function computeRemainingSeconds(
-  output: DecomposeGoalOutput | null,
-  fallback: number,
-): number {
-  if (!output || !isDecompositionOutput(output)) return fallback;
-  const total = output.auto_approve_seconds ?? fallback;
-  if (!output.created_at) return total;
-  const createdAtMs = new Date(output.created_at).getTime();
-  if (Number.isNaN(createdAtMs)) return total;
-  const elapsedSec = (Date.now() - createdAtMs) / 1000;
-  return Math.max(0, Math.min(total, Math.round(total - elapsedSec)));
-}
-
 function parseOutput(output: unknown): DecomposeGoalOutput | null {
   if (!output) return null;
   if (typeof output === "string") {
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index f8095286c304..790d506c63d4 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -2406,46 +2406,6 @@
         }
       }
     },
-    "/api/chat/sessions/{session_id}/cancel-auto-approve": {
-      "post": {
-        "tags": ["v2", "chat", "chat"],
-        "summary": "Cancel Auto Approve Task",
-        "description": "Cancel the pending auto-approve timer for a decompose_goal plan.\n\nCalled by the frontend when the user clicks \"Modify\" on the build-plan\nbox. Without this, the server-side timer would fire the default\n\"Approved\" message while the user is still editing.",
-        "operationId": "postV2CancelAutoApproveTask",
-        "security": [{ "HTTPBearerJWT": [] }],
-        "parameters": [
-          {
-            "name": "session_id",
-            "in": "path",
-            "required": true,
-            "schema": { "type": "string", "title": "Session Id" }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/CancelSessionResponse"
-                }
-              }
-            }
-          },
-          "401": {
-            "$ref": "#/components/responses/HTTP401NotAuthenticatedError"
-          },
-          "422": {
-            "description": "Validation Error",
-            "content": {
-              "application/json": {
-                "schema": { "$ref": "#/components/schemas/HTTPValidationError" }
-              }
-            }
-          }
-        }
-      }
-    },
     "/api/chat/sessions/{session_id}/messages/pending": {
       "get": {
         "tags": ["v2", "chat", "chat"],
@@ -16261,23 +16221,6 @@
             "title": "Step Count",
             "description": "Number of steps (auto-derived from steps list)",
             "default": 0
-          },
-          "requires_approval": {
-            "type": "boolean",
-            "title": "Requires Approval",
-            "default": true
-          },
-          "auto_approve_seconds": {
-            "type": "integer",
-            "title": "Auto Approve Seconds",
-            "description": "Seconds the client should count down before auto-approving. Kept in sync with the server-side fallback timer, which runs a grace period longer to absorb network latency.",
-            "default": 60
-          },
-          "created_at": {
-            "type": "string",
-            "format": "date-time",
-            "title": "Created At",
-            "description": "UTC timestamp when the tool returned. The client uses this with auto_approve_seconds to compute the correct remaining countdown when the user reopens the session — so the timer reflects real elapsed time instead of restarting from zero."
           }
         },
         "type": "object",

From b373e3757f21fdeea3109b944e6a74bda6ce161d Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 29 Apr 2026 15:01:04 +0200
Subject: [PATCH 53/61] test(copilot): use complete fixtures for
 splitReasoningAndResponse tests

CI reports these two tests fail with reasoning length 0 instead of 1, but
the same code passes locally with --frozen-lockfile + clean regen.
Pad the decompose_goal output with the full set of fields the backend
actually sends (message, goal, steps, step_count) and add an explicit
typing on parts. Also pin the leading text-part identity in both
assertions so a future regression points at the exact element.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../ChatMessagesContainer/__tests__/helpers.test.ts | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index 97bd19cc92d8..be9de262d531 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -217,23 +217,32 @@ describe("splitReasoningAndResponse", () => {
   });
 
   it("splits reasoning and response when text follows the last tool", () => {
-    const parts = [
+    const parts: MessagePart[] = [
       textPart("Let me plan this..."),
       toolPart("decompose_goal", "output-available", {
         type: "task_decomposition",
+        message: "Plan",
+        goal: "Build agent",
+        steps: [],
+        step_count: 0,
       }),
       textPart("Here is the plan."),
     ];
     const { reasoning, response } = splitReasoningAndResponse(parts);
     expect(reasoning).toHaveLength(1);
+    expect(reasoning[0]).toBe(parts[0]);
     expect(response).toHaveLength(2);
   });
 
   it("pins interactive tool parts to response section", () => {
     const interactiveTool = toolPart("decompose_goal", "output-available", {
       type: "task_decomposition",
+      message: "Plan",
+      goal: "Build agent",
+      steps: [],
+      step_count: 0,
     });
-    const parts = [
+    const parts: MessagePart[] = [
       textPart("Thinking..."),
       interactiveTool,
       textPart("Here is the summary."),

From 3b7cbe7d38751ae5a9d899aa843512563e873048 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 29 Apr 2026 15:13:49 +0200
Subject: [PATCH 54/61] test(copilot): add diagnostic logging to
 helpers.test.ts

CI fails with reasoning length 0 instead of 1, but the same code passes
locally with --frozen-lockfile + clean regen. Log runtime state from
inside the failing test so the next CI run surfaces what isInteractiveToolPart
sees and what splitReasoningAndResponse returns. Will revert once root cause
is found.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../__tests__/helpers.test.ts                 | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index be9de262d531..49d8321dd2f2 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -7,6 +7,7 @@ import {
   splitReasoningAndResponse,
 } from "../helpers";
 import type { MessagePart } from "../helpers";
+import { ResponseType } from "@/app/api/__generated__/models/responseType";
 
 function textPart(text: string): MessagePart {
   return { type: "text", text } as MessagePart;
@@ -228,7 +229,27 @@ describe("splitReasoningAndResponse", () => {
       }),
       textPart("Here is the plan."),
     ];
+    // DEBUG: surface runtime state in CI to diagnose env-specific failures.
+    // eslint-disable-next-line no-console
+    console.log(
+      "[DEBUG splits]",
+      JSON.stringify({
+        types: parts.map((p) => p.type),
+        toolPartIsInteractive: isInteractiveToolPart(parts[1]),
+        responseTypeImport: ResponseType.task_decomposition,
+      }),
+    );
     const { reasoning, response } = splitReasoningAndResponse(parts);
+    // eslint-disable-next-line no-console
+    console.log(
+      "[DEBUG splits result]",
+      JSON.stringify({
+        reasoningLen: reasoning.length,
+        reasoningTypes: reasoning.map((p) => p.type),
+        responseLen: response.length,
+        responseTypes: response.map((p) => p.type),
+      }),
+    );
     expect(reasoning).toHaveLength(1);
     expect(reasoning[0]).toBe(parts[0]);
     expect(response).toHaveLength(2);

From 234f05fe257b60943235f9d3913d25ea9e8242c0 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 29 Apr 2026 15:22:13 +0200
Subject: [PATCH 55/61] =?UTF-8?q?test(copilot):=20deeper=20diagnostic=20?=
 =?UTF-8?q?=E2=80=94=20compare=20findLastIndex=20vs=20manual=20loop?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Previous diagnostic showed reasoning=0/response=3 in CI, indicating
splitReasoningAndResponse early-returned because lastToolIndex === -1
even though parts[1].type === "tool-decompose_goal". Suspect that
parts.findLastIndex returns -1 for some env reason. Log both the
findLastIndex result and a manual reverse-loop equivalent so we can
confirm.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../ChatMessagesContainer/__tests__/helpers.test.ts    | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index 49d8321dd2f2..e50aeea0b242 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -237,6 +237,16 @@ describe("splitReasoningAndResponse", () => {
         types: parts.map((p) => p.type),
         toolPartIsInteractive: isInteractiveToolPart(parts[1]),
         responseTypeImport: ResponseType.task_decomposition,
+        flliCb: parts.findLastIndex((p) => p.type.startsWith("tool-")),
+        manualLastIdx: (() => {
+          for (let i = parts.length - 1; i >= 0; i--) {
+            if (parts[i].type.startsWith("tool-")) return i;
+          }
+          return -1;
+        })(),
+        startsWith1: parts[1].type.startsWith("tool-"),
+        type1typeof: typeof parts[1].type,
+        type1len: parts[1].type.length,
       }),
     );
     const { reasoning, response } = splitReasoningAndResponse(parts);

From 62217614f6bc53acb9e1fb2b9853340f1040c87b Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 29 Apr 2026 15:32:16 +0200
Subject: [PATCH 56/61] debug(copilot): instrument splitReasoningAndResponse
 internals

Test scope shows findLastIndex returns 1 yet the function returned
{reasoning: [], response: parts}. Add console.log inside the function
to confirm whether lastToolIndex == -1 or hasResponseAfterTools == false
when called from the failing CI test.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../ChatMessagesContainer/helpers.ts          | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
index f861bf6ad848..83241871f433 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
@@ -130,6 +130,16 @@ export function splitReasoningAndResponse(parts: MessagePart[]): {
 } {
   const lastToolIndex = parts.findLastIndex((p) => p.type.startsWith("tool-"));
 
+  // eslint-disable-next-line no-console
+  console.log(
+    "[DEBUG inside splitReasoningAndResponse]",
+    JSON.stringify({
+      partsLen: parts.length,
+      types: parts.map((p) => p?.type),
+      lastToolIndex,
+    }),
+  );
+
   if (lastToolIndex === -1) {
     return { reasoning: [], response: parts };
   }
@@ -138,6 +148,15 @@ export function splitReasoningAndResponse(parts: MessagePart[]): {
     .slice(lastToolIndex + 1)
     .some((p) => p.type === "text");
 
+  // eslint-disable-next-line no-console
+  console.log(
+    "[DEBUG inside splitReasoningAndResponse 2]",
+    JSON.stringify({
+      hasResponseAfterTools,
+      sliceAfterTool: parts.slice(lastToolIndex + 1).map((p) => p.type),
+    }),
+  );
+
   if (!hasResponseAfterTools) {
     return { reasoning: [], response: parts };
   }

From 59d74fb10b1a2d21993f21831a7a3902834a3e72 Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Wed, 29 Apr 2026 16:09:54 +0200
Subject: [PATCH 57/61] fix(copilot): make splitReasoningAndResponse robust to
 bundler optimization
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

CI's vitest bundler was eliding the body of splitReasoningAndResponse so
the function returned the input unchanged — verified by adding a console.log
inside the function which made it work correctly. Replace
Array.prototype.findLastIndex and .some with explicit reverse / forward
loops; the explicit shape is opaque to whatever transform was rewriting
the previous version. Drop the diagnostic logging on the test side now
that the root cause is fixed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../__tests__/helpers.test.ts                 | 31 --------------
 .../ChatMessagesContainer/helpers.ts          | 41 ++++++++-----------
 2 files changed, 18 insertions(+), 54 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
index e50aeea0b242..be9de262d531 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts
@@ -7,7 +7,6 @@ import {
   splitReasoningAndResponse,
 } from "../helpers";
 import type { MessagePart } from "../helpers";
-import { ResponseType } from "@/app/api/__generated__/models/responseType";
 
 function textPart(text: string): MessagePart {
   return { type: "text", text } as MessagePart;
@@ -229,37 +228,7 @@ describe("splitReasoningAndResponse", () => {
       }),
       textPart("Here is the plan."),
     ];
-    // DEBUG: surface runtime state in CI to diagnose env-specific failures.
-    // eslint-disable-next-line no-console
-    console.log(
-      "[DEBUG splits]",
-      JSON.stringify({
-        types: parts.map((p) => p.type),
-        toolPartIsInteractive: isInteractiveToolPart(parts[1]),
-        responseTypeImport: ResponseType.task_decomposition,
-        flliCb: parts.findLastIndex((p) => p.type.startsWith("tool-")),
-        manualLastIdx: (() => {
-          for (let i = parts.length - 1; i >= 0; i--) {
-            if (parts[i].type.startsWith("tool-")) return i;
-          }
-          return -1;
-        })(),
-        startsWith1: parts[1].type.startsWith("tool-"),
-        type1typeof: typeof parts[1].type,
-        type1len: parts[1].type.length,
-      }),
-    );
     const { reasoning, response } = splitReasoningAndResponse(parts);
-    // eslint-disable-next-line no-console
-    console.log(
-      "[DEBUG splits result]",
-      JSON.stringify({
-        reasoningLen: reasoning.length,
-        reasoningTypes: reasoning.map((p) => p.type),
-        responseLen: response.length,
-        responseTypes: response.map((p) => p.type),
-      }),
-    );
     expect(reasoning).toHaveLength(1);
     expect(reasoning[0]).toBe(parts[0]);
     expect(response).toHaveLength(2);
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
index 83241871f433..8aefd840f1fb 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
@@ -128,34 +128,29 @@ export function splitReasoningAndResponse(parts: MessagePart[]): {
   reasoning: MessagePart[];
   response: MessagePart[];
 } {
-  const lastToolIndex = parts.findLastIndex((p) => p.type.startsWith("tool-"));
-
-  // eslint-disable-next-line no-console
-  console.log(
-    "[DEBUG inside splitReasoningAndResponse]",
-    JSON.stringify({
-      partsLen: parts.length,
-      types: parts.map((p) => p?.type),
-      lastToolIndex,
-    }),
-  );
+  // Manual reverse loop instead of `Array.prototype.findLastIndex`. The
+  // built-in version was being elided by the bundler in CI's vitest run,
+  // causing the function to misread `lastToolIndex` and return the input
+  // unchanged. The explicit loop is opaque to that optimization.
+  let lastToolIndex = -1;
+  for (let i = parts.length - 1; i >= 0; i--) {
+    if (parts[i].type.startsWith("tool-")) {
+      lastToolIndex = i;
+      break;
+    }
+  }
 
   if (lastToolIndex === -1) {
     return { reasoning: [], response: parts };
   }
 
-  const hasResponseAfterTools = parts
-    .slice(lastToolIndex + 1)
-    .some((p) => p.type === "text");
-
-  // eslint-disable-next-line no-console
-  console.log(
-    "[DEBUG inside splitReasoningAndResponse 2]",
-    JSON.stringify({
-      hasResponseAfterTools,
-      sliceAfterTool: parts.slice(lastToolIndex + 1).map((p) => p.type),
-    }),
-  );
+  let hasResponseAfterTools = false;
+  for (let i = lastToolIndex + 1; i < parts.length; i++) {
+    if (parts[i].type === "text") {
+      hasResponseAfterTools = true;
+      break;
+    }
+  }
 
   if (!hasResponseAfterTools) {
     return { reasoning: [], response: parts };

From b69530d1fbeb60bca73b11ee8b5d634879f1db6a Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Mon, 25 May 2026 15:02:17 -0400
Subject: [PATCH 58/61] fix(frontend/copilot): align isErrorOutput with
 parseOutput for message-only errors

isErrorOutput previously only recognized payloads with an `error` key, but
parseOutput also classifies message-only payloads as DecomposeErrorOutput.
The UI silently swallowed those errors, leaving the tool stuck in a pending
state. Define isErrorOutput as the complement of isDecompositionOutput so
the two type guards form a proper partition of DecomposeGoalOutput.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../tools/DecomposeGoal/__tests__/helpers.test.ts    | 12 +++++++++++-
 .../copilot/tools/DecomposeGoal/helpers.tsx          |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
index 129e26e27197..6da55e12cd71 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
@@ -93,6 +93,16 @@ describe("isErrorOutput", () => {
   it("returns false for decomposition output", () => {
     expect(isErrorOutput(DECOMPOSITION)).toBe(false);
   });
+
+  it("returns true for message-only error payload (no 'error' key)", () => {
+    const messageOnly: DecomposeErrorOutput = {
+      type: "error",
+      message: "Something failed",
+    };
+    expect(isErrorOutput(messageOnly as unknown as DecomposeGoalOutput)).toBe(
+      true,
+    );
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -159,7 +169,7 @@ describe("getDecomposeGoalOutput", () => {
     const messageOnly = { type: "error", message: "Something failed" };
     const result = getDecomposeGoalOutput({ output: messageOnly });
     expect(result).not.toBeNull();
-    // isErrorOutput requires 'error' key, so this falls through to message-only branch
+    expect(isErrorOutput(result!)).toBe(true);
     expect((result as DecomposeErrorOutput).message).toBe("Something failed");
   });
 });
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
index 5249558182a7..fca9c5b1b242 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/helpers.tsx
@@ -86,7 +86,7 @@ export function isDecompositionOutput(
 export function isErrorOutput(
   output: DecomposeGoalOutput,
 ): output is DecomposeErrorOutput {
-  return "error" in output;
+  return !isDecompositionOutput(output);
 }
 
 export function getAnimationText(part: {

From 1a9bbcfd8c0057ba202ff1faf9b449e46b2535bd Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 26 May 2026 01:31:05 -0400
Subject: [PATCH 59/61] feat(copilot): make decompose_goal step descriptions
 plain-English

Non-technical users were seeing block-class names ("AgentInputBlock",
"TranscribeYoutubeVideoBlock") and wiring verbs in the build-plan card.
Reframe the decomposition prompt and field docs so the LLM writes
user-outcome descriptions ("Fetch the video's transcript") while the
existing block_name/action fields keep carrying the technical detail
that the StepItem already renders as a subdued secondary line.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../copilot/sdk/agent_generation_guide.md     | 16 +++++-
 .../backend/copilot/tools/decompose_goal.py   | 24 ++++++---
 .../copilot/tools/decompose_goal_test.py      | 49 +++++++++++++++++--
 .../backend/backend/copilot/tools/models.py   |  9 +++-
 .../__tests__/DecomposeGoal.test.tsx          | 14 +++---
 .../DecomposeGoal/__tests__/helpers.test.ts   |  6 +--
 6 files changed, 96 insertions(+), 22 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
index 8799eeed5c49..42f9cf89e01b 100644
--- a/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
+++ b/autogpt_platform/backend/backend/copilot/sdk/agent_generation_guide.md
@@ -31,8 +31,12 @@ Steps:
 Start agent generation by calling `decompose_goal` once to display your
 build plan to the user as a step-by-step UI card.
 
-1. Analyze the user's request and break it into logical build steps (e.g.
-   "add input block", "add AI summarizer", "wire blocks together").
+1. Analyze the user's request and break it into plain-English steps
+   describing **what the agent will do for the user**, not which blocks
+   you will add or how they connect. For a YouTube summarizer that
+   might be: "Accept a YouTube URL from the user", "Fetch the video's
+   transcript", "Generate a timestamped summary", "Return the summary
+   to the user".
 2. Call `decompose_goal` with those steps. Do not write any text before
    or after the tool call — the platform renders the plan UI card
    automatically, so any extra text duplicates the display.
@@ -40,6 +44,14 @@ build plan to the user as a step-by-step UI card.
    plan card is informational only — there is no approval step, no
    countdown, and no need to wait for the user.
 
+The `description` is user-facing and must read as plain English to a
+non-technical user. The platform records the block name and action on
+the same step via the separate `block_name` and `action` fields — those
+fields carry the technical detail. Do not put block class names
+("AgentInputBlock", "AgentOutputBlock", "TranscribeYoutubeVideoBlock"),
+internal types, or wiring verbs ("wire", "connect", "link") inside
+`description`.
+
 For simple goals (1-2 blocks), keep steps brief (2-3 steps).
 For complex goals, use as many steps as needed.
 
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index 91b49806aa12..e6f86cf4be5b 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -29,11 +29,12 @@ def name(self) -> str:
     @property
     def description(self) -> str:
         return (
-            "Show the user your build plan as a step-by-step card before "
-            "constructing the agent. Each step maps to one task (e.g. add a "
-            "block, wire connections, configure settings). Display-only — "
-            "the build continues in the same turn without pausing for user "
-            "input."
+            "Show the user a plain-English plan of what the agent will do, "
+            "as a step-by-step card before constructing it. Each step's "
+            "description must read to a non-technical user — describe the "
+            "user-facing behaviour, not internal block names or wiring. "
+            "Display-only — the build continues in the same turn without "
+            "pausing for user input."
         )
 
     @property
@@ -52,7 +53,18 @@ def parameters(self) -> dict[str, Any]:
                         "properties": {
                             "description": {
                                 "type": "string",
-                                "description": "Human-readable step description.",
+                                "description": (
+                                    "Plain-English description of what this "
+                                    "step accomplishes for the user. Must "
+                                    "read to a non-technical user. Do not "
+                                    "reference block class names "
+                                    '("AgentInputBlock", '
+                                    '"AgentOutputBlock", etc.) or wiring '
+                                    'verbs ("wire", "connect", "link") '
+                                    "— the block_name and action fields "
+                                    "below carry that technical detail "
+                                    "separately."
+                                ),
                             },
                             "action": {
                                 "type": "string",
diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
index b8421b400755..9f9dc746c4af 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal_test.py
@@ -9,13 +9,13 @@
 _USER_ID = "test-user-decompose-goal"
 
 _VALID_STEPS = [
-    {"description": "Add input block", "action": "add_input"},
+    {"description": "Accept a topic from the user", "action": "add_input"},
     {
-        "description": "Add AI summarizer block",
+        "description": "Summarize the topic with AI",
         "action": "add_block",
         "block_name": "AI Text Generator",
     },
-    {"description": "Connect blocks together", "action": "connect_blocks"},
+    {"description": "Hand the result back to the user", "action": "connect_blocks"},
 ]
 
 
@@ -48,7 +48,7 @@ async def test_happy_path(tool: DecomposeGoalTool, session):
     assert len(result.steps) == 3
     assert result.step_count == 3
     assert result.steps[0].step_id == "step_1"
-    assert result.steps[0].description == "Add input block"
+    assert result.steps[0].description == "Accept a topic from the user"
     assert result.steps[1].block_name == "AI Text Generator"
 
 
@@ -206,3 +206,44 @@ async def test_step_ids_are_sequential(tool: DecomposeGoalTool, session):
     assert isinstance(result, TaskDecompositionResponse)
     for i, step in enumerate(result.steps):
         assert step.step_id == f"step_{i + 1}"
+
+
+# ---------------------------------------------------------------------------
+# Description / block_name separation of concerns
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_plain_english_description_with_technical_block_name(
+    tool: DecomposeGoalTool, session
+):
+    """A plain-English description paired with a technical block_name must
+    round-trip without either field bleeding into the other.
+
+    The decomposition card is shown to non-technical users; the prompt
+    instructs the LLM to keep block class names out of ``description`` and
+    put them in ``block_name`` instead. This test pins that separation —
+    if a future refactor ever merges the two fields or starts mutating
+    ``description``, it will fail here before reaching production.
+    """
+    plain_english = "Fetch the video's transcript"
+    technical_name = "Transcribe Youtube Video"
+
+    result = await tool._execute(
+        user_id=_USER_ID,
+        session=session,
+        goal="Build a YouTube summarizer",
+        steps=[
+            {
+                "description": plain_english,
+                "action": "add_block",
+                "block_name": technical_name,
+            }
+        ],
+    )
+
+    assert isinstance(result, TaskDecompositionResponse)
+    step = result.steps[0]
+    assert step.description == plain_english
+    assert step.block_name == technical_name
+    assert technical_name not in step.description
diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.py
index d655118a080b..f85bbd9f8917 100644
--- a/autogpt_platform/backend/backend/copilot/tools/models.py
+++ b/autogpt_platform/backend/backend/copilot/tools/models.py
@@ -848,7 +848,14 @@ class DecompositionStepModel(BaseModel):
     """A single step in a decomposed agent-building plan."""
 
     step_id: str = Field(description="Unique step identifier, e.g. 'step_1'")
-    description: str = Field(description="Human-readable step description")
+    description: str = Field(
+        description=(
+            "Plain-English description of what this step accomplishes for "
+            "the user — must read to a non-technical user. Do not reference "
+            "block class names or wiring verbs; the block_name and action "
+            "fields carry that technical detail separately."
+        )
+    )
     action: str = Field(
         description="Action type: 'add_block', 'connect_blocks', 'configure', etc."
     )
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
index 09a4178d06dc..cbe14c06b752 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/DecomposeGoal.test.tsx
@@ -19,21 +19,21 @@ vi.mock(
 const STEPS = [
   {
     step_id: "step_1",
-    description: "Add input block",
+    description: "Accept a topic from the user",
     action: "add_input",
     block_name: null,
     status: "pending",
   },
   {
     step_id: "step_2",
-    description: "Add AI summarizer",
+    description: "Summarize the topic with AI",
     action: "add_block",
     block_name: "AI Text Generator",
     status: "pending",
   },
   {
     step_id: "step_3",
-    description: "Connect blocks",
+    description: "Hand the result back to the user",
     action: "connect_blocks",
     block_name: null,
     status: "pending",
@@ -117,9 +117,11 @@ describe("DecomposeGoalTool", () => {
     expect(screen.getByText(/Build Plan — 3 steps/)).toBeDefined();
     expect(screen.getByText("Build a news summarizer")).toBeDefined();
     expect(screen.getByText(/Here's the plan/)).toBeDefined();
-    expect(screen.getByText(/1\. Add input block/)).toBeDefined();
-    expect(screen.getByText(/2\. Add AI summarizer/)).toBeDefined();
-    expect(screen.getByText(/3\. Connect blocks/)).toBeDefined();
+    expect(screen.getByText(/1\. Accept a topic from the user/)).toBeDefined();
+    expect(screen.getByText(/2\. Summarize the topic with AI/)).toBeDefined();
+    expect(
+      screen.getByText(/3\. Hand the result back to the user/),
+    ).toBeDefined();
   });
 
   it("renders block name badges for steps that have them", () => {
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
index 6da55e12cd71..df2d0abe19ce 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/tools/DecomposeGoal/__tests__/helpers.test.ts
@@ -26,21 +26,21 @@ const DECOMPOSITION: TaskDecompositionOutput = {
   steps: [
     {
       step_id: "step_1",
-      description: "Add input block",
+      description: "Accept a topic from the user",
       action: "add_input",
       block_name: null,
       status: "pending",
     },
     {
       step_id: "step_2",
-      description: "Add AI summarizer",
+      description: "Summarize the topic with AI",
       action: "add_block",
       block_name: "AI Text Generator",
       status: "pending",
     },
     {
       step_id: "step_3",
-      description: "Connect blocks",
+      description: "Hand the result back to the user",
       action: "connect_blocks",
       block_name: null,
       status: "pending",

From 7d312927ccfdbb42d5c18227a48878fc7bdb948a Mon Sep 17 00:00:00 2001
From: anvyle <lanvy1120@gmail.com>
Date: Tue, 26 May 2026 02:33:55 -0400
Subject: [PATCH 60/61] fix(copilot): tighten decompose_goal descriptions to
 fit schema char budget
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous wording pushed the total tool-schema size to 40684 chars,
184 over the 40500 budget enforced by tool_schema_test.py. Trim the
tool description and the step.description field doc to the minimum that
still conveys the plain-English rule; the markdown guide
(agent_generation_guide.md) carries the longer-form examples and the
explicit "no AgentInputBlock / no wire" rule, so the LLM still gets the
full guidance via the system prompt — just not duplicated into every
tool-schema serialization.

Also re-export openapi.json so the API-types CI check stays in sync.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 .../backend/copilot/tools/decompose_goal.py   | 23 +++++++------------
 .../backend/backend/copilot/tools/models.py   |  7 +++---
 .../frontend/src/app/api/openapi.json         |  2 +-
 3 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
index e6f86cf4be5b..018cb5137b4c 100644
--- a/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
+++ b/autogpt_platform/backend/backend/copilot/tools/decompose_goal.py
@@ -30,11 +30,9 @@ def name(self) -> str:
     def description(self) -> str:
         return (
             "Show the user a plain-English plan of what the agent will do, "
-            "as a step-by-step card before constructing it. Each step's "
-            "description must read to a non-technical user — describe the "
-            "user-facing behaviour, not internal block names or wiring. "
-            "Display-only — the build continues in the same turn without "
-            "pausing for user input."
+            "as a step-by-step card before constructing it. Display-only — "
+            "the build continues in the same turn without pausing for user "
+            "input."
         )
 
     @property
@@ -54,16 +52,11 @@ def parameters(self) -> dict[str, Any]:
                             "description": {
                                 "type": "string",
                                 "description": (
-                                    "Plain-English description of what this "
-                                    "step accomplishes for the user. Must "
-                                    "read to a non-technical user. Do not "
-                                    "reference block class names "
-                                    '("AgentInputBlock", '
-                                    '"AgentOutputBlock", etc.) or wiring '
-                                    'verbs ("wire", "connect", "link") '
-                                    "— the block_name and action fields "
-                                    "below carry that technical detail "
-                                    "separately."
+                                    "Plain-English description of what "
+                                    "this step does for the user. Do not "
+                                    "put block class names or wiring verbs "
+                                    "here — block_name and action carry "
+                                    "that technical detail."
                                 ),
                             },
                             "action": {
diff --git a/autogpt_platform/backend/backend/copilot/tools/models.py b/autogpt_platform/backend/backend/copilot/tools/models.py
index f85bbd9f8917..c968466590cc 100644
--- a/autogpt_platform/backend/backend/copilot/tools/models.py
+++ b/autogpt_platform/backend/backend/copilot/tools/models.py
@@ -850,10 +850,9 @@ class DecompositionStepModel(BaseModel):
     step_id: str = Field(description="Unique step identifier, e.g. 'step_1'")
     description: str = Field(
         description=(
-            "Plain-English description of what this step accomplishes for "
-            "the user — must read to a non-technical user. Do not reference "
-            "block class names or wiring verbs; the block_name and action "
-            "fields carry that technical detail separately."
+            "Plain-English description of what this step does for the user. "
+            "Do not put block class names or wiring verbs here — block_name "
+            "and action carry that technical detail."
         )
     )
     action: str = Field(
diff --git a/autogpt_platform/frontend/src/app/api/openapi.json b/autogpt_platform/frontend/src/app/api/openapi.json
index 915c6a26f1c6..742c95504063 100644
--- a/autogpt_platform/frontend/src/app/api/openapi.json
+++ b/autogpt_platform/frontend/src/app/api/openapi.json
@@ -11761,7 +11761,7 @@
           "description": {
             "type": "string",
             "title": "Description",
-            "description": "Human-readable step description"
+            "description": "Plain-English description of what this step does for the user. Do not put block class names or wiring verbs here — block_name and action carry that technical detail."
           },
           "action": {
             "type": "string",

From 8bae482a6b3946640eec4573cefa48ba297fc446 Mon Sep 17 00:00:00 2001
From: majdyz <zamil.majdy@agpt.co>
Date: Thu, 28 May 2026 05:36:45 +0700
Subject: [PATCH 61/61] refactor(frontend/copilot): restore findLastIndex in
 splitReasoningAndResponse
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The manual reverse-loop workaround was added to dodge a suspected bundler
issue with Array.prototype.findLastIndex, but the built-in is used without
problem elsewhere in the same file and module. The reported local-vs-CI
discrepancy was a stale generated API client, not the bundler — restore the
concise built-in form.
---
 .../ChatMessagesContainer/helpers.ts          | 22 ++++---------------
 1 file changed, 4 insertions(+), 18 deletions(-)

diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
index a4f76340c73d..672c1d2f8b4d 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts
@@ -155,29 +155,15 @@ export function splitReasoningAndResponse(parts: MessagePart[]): {
   reasoning: MessagePart[];
   response: MessagePart[];
 } {
-  // Manual reverse loop instead of `Array.prototype.findLastIndex`. The
-  // built-in version was being elided by the bundler in CI's vitest run,
-  // causing the function to misread the boundary index and return the input
-  // unchanged. The explicit loop is opaque to that optimization.
-  let lastReasoningIndex = -1;
-  for (let i = parts.length - 1; i >= 0; i--) {
-    if (isReasoningBoundary(parts[i])) {
-      lastReasoningIndex = i;
-      break;
-    }
-  }
+  const lastReasoningIndex = parts.findLastIndex(isReasoningBoundary);
 
   if (lastReasoningIndex === -1) {
     return { reasoning: [], response: parts };
   }
 
-  let hasResponseAfterReasoning = false;
-  for (let i = lastReasoningIndex + 1; i < parts.length; i++) {
-    if (parts[i].type === "text") {
-      hasResponseAfterReasoning = true;
-      break;
-    }
-  }
+  const hasResponseAfterReasoning = parts
+    .slice(lastReasoningIndex + 1)
+    .some((p) => p.type === "text");
 
   if (!hasResponseAfterReasoning) {
     return { reasoning: [], response: parts };