Clear sticky task activity after successful turn completion

Remove completed task and worker rows only after successful final-turn reconciliation, while retaining activity for failed turns.

Co-authored-by: Autohand Evolve <code-noreply@autohand.ai>

Author: igorcosta

src/core/agent.ts

@@ -210,6 +210,7 @@ import {
   buildAgentSpinnerStatusText,
   withPeerLineExtension,
   cleanupAgentUI,
+  clearAgentActivityForCompletedTurn,
   clearAgentComposerInput,
   ensureAgentSpinnerRunning,
   executeAgentImmediateShellCommand,
@@ -1219,6 +1220,10 @@ export class AutohandAgent {
     return this.actionExecutor?.completeTodoActivityForSuccessfulTurn() ?? false;
   }
 
+  private clearActivityForCompletedTurn(): void {
+    return clearAgentActivityForCompletedTurn(this);
+  }
+
   private createReactLoopHost(): AgentReactLoopHost {
     const agent = this;
 

src/core/agent/AgentUIRuntime.ts

@@ -376,6 +376,10 @@ export function setAgentComposerIdle(host: AgentUIRuntimeHost): void {
     host.ui?.setWorking(false);
   }
 
+export function clearAgentActivityForCompletedTurn(host: AgentUIRuntimeHost): void {
+    host.inkRenderer?.clearActivityItems?.();
+  }
+
 export function clearAgentComposerInput(host: AgentUIRuntimeHost): void {
     host.inkRenderer?.clearInput();
     host.ui?.clearInput();

src/core/agent/InstructionRunner.ts

@@ -160,6 +160,7 @@ export interface AgentInstructionHost {
   printCompletionSummary(regionsStillActive: boolean, succeeded?: boolean): void;
   beginTodoActivityTurn?(): void;
   completeTodoActivityForSuccessfulTurn?(): Promise<boolean>;
+  clearActivityForCompletedTurn?(): void;
   scheduleTurnMemoryReflection(outcome: TurnMemoryReflectionOutcome): void;
   writeDebugLine?(message: string): void;
 }
@@ -456,6 +457,7 @@ export class InstructionRunner {
       success = await finalizeResearchForTurn(success);
       if (success) {
         await host.completeTodoActivityForSuccessfulTurn?.();
+        host.clearActivityForCompletedTurn?.();
       }
     } catch (error) {
       success = false;
@@ -543,6 +545,7 @@ export class InstructionRunner {
             success = await finalizeResearchForTurn(success);
             if (success) {
               await host.completeTodoActivityForSuccessfulTurn?.();
+              host.clearActivityForCompletedTurn?.();
             }
             return success;
           } catch (retryError) {

tests/core/agent/InstructionRunner.command-mode.test.ts

@@ -223,6 +223,23 @@ describe('InstructionRunner command mode UI', () => {
     expect(host.scheduleTurnMemoryReflection).toHaveBeenCalledWith({ status: 'succeeded' });
   });
 
+  it('clears sticky activity after a successful turn reaches final completion', async () => {
+    const host = createHost();
+    const completeTodoActivityForSuccessfulTurn = vi.fn(async () => true);
+    const clearActivityForCompletedTurn = vi.fn();
+    const activityHost = host as AgentInstructionHost & {
+      completeTodoActivityForSuccessfulTurn: () => Promise<boolean>;
+      clearActivityForCompletedTurn: () => void;
+    };
+    activityHost.completeTodoActivityForSuccessfulTurn = completeTodoActivityForSuccessfulTurn;
+    activityHost.clearActivityForCompletedTurn = clearActivityForCompletedTurn;
+
+    await expect(new InstructionRunner(activityHost).run('finish the active task')).resolves.toBe(true);
+
+    expect(completeTodoActivityForSuccessfulTurn).toHaveBeenCalledOnce();
+    expect(clearActivityForCompletedTurn).toHaveBeenCalledOnce();
+  });
+
   it('keeps the Ink renderer mounted while running quality checks after an implementation turn', async () => {
     const host = createHost();
     const inkRenderer = {
@@ -253,6 +270,10 @@ describe('InstructionRunner command mode UI', () => {
 
   it('marks the turn failed when project quality checks fail', async () => {
     const host = createHost();
+    const clearActivityForCompletedTurn = vi.fn();
+    (host as AgentInstructionHost & {
+      clearActivityForCompletedTurn: () => void;
+    }).clearActivityForCompletedTurn = clearActivityForCompletedTurn;
     host.runtime = {
       ...host.runtime,
       options: {},
@@ -270,6 +291,7 @@ describe('InstructionRunner command mode UI', () => {
 
     expect(result).toBe(false);
     expect(host.stopUI).toHaveBeenCalledWith(true, 'Quality checks failed');
+    expect(clearActivityForCompletedTurn).not.toHaveBeenCalled();
     expect(host.printCompletionSummary).toHaveBeenCalledWith(false, false);
     expect(host.scheduleTurnMemoryReflection).toHaveBeenCalledWith({
       status: 'failed',

tests/tuistory/task-activity.tuistory.test.ts

@@ -48,7 +48,7 @@ afterEach(async () => {
 });
 
 describe('interactive task activity', () => {
-  it('finishes the visible plan and keeps the final summary above the composer', async () => {
+  it('removes completed task activity when the final turn reaches the composer', async () => {
     const server = await createMockOpenRouterSequenceServer([
       JSON.stringify({
         thought: 'Create a five-step plan and start the validation.',
@@ -103,15 +103,16 @@ describe('interactive task activity', () => {
 
     const viewport = await waitForActiveViewport(
       session,
-      (text) => text.includes('5/5 done')
-        && text.includes('TASK_ACTIVITY_FINAL_SUMMARY')
-        && text.includes('All 5 tasks completed')
+      (text) => text.includes('TASK_ACTIVITY_FINAL_SUMMARY')
         && text.includes('Completed in')
-        && text.includes('❯'),
+        && text.includes('❯')
+        && !text.includes('Tasks')
+        && !text.includes('All 5 tasks completed'),
     );
 
-    expect(viewport).toContain('100%');
-    expect(viewport).not.toContain('in progress · 1');
+    expect(viewport).not.toContain('5/5 done');
+    expect(viewport).not.toContain('100%');
+    expect(viewport).not.toContain('Report the task-view result');
 
     await exitInteractive(session);
   }, 60_000);

tests/ui/ink/InkRenderer.test.ts

@@ -86,6 +86,28 @@ describe('InkRenderer live command blocks', () => {
     ]);
   });
 
+  it('clears completed todo and worker activity after final turn completion', () => {
+    const renderer = new InkRenderer({
+      onInstruction: () => {},
+      onEscape: () => {},
+      onCtrlC: () => {},
+    });
+
+    renderer.setTodoActivityItems([
+      { id: 'todo-1', kind: 'todo', label: 'Review the final task', status: 'completed' },
+    ]);
+    renderer.upsertActivityItem({
+      id: 'worker-1',
+      kind: 'subagent',
+      label: 'reviewer: validate the result',
+      status: 'completed',
+    });
+
+    renderer.clearActivityItems();
+
+    expect(renderer.getState().activityItems).toEqual([]);
+  });
+
   it('records grouped parallel tool output as a single batch chat message', () => {
     const renderer = new InkRenderer({
       onInstruction: () => {},