fix(agent-core-v2): keep late task settlement silent after agent teardown

A background task can settle after its agent is gone. Gate the task-started,
task-terminated and notification paths on the agent still being active, and
stop tasks after the loop reaches quiescence rather than before it drains, so
a late settle cannot reach the wire.

Author: elkaix

.changeset/silent-late-task-settlement.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": patch
+---
+
+A background task that finishes after its agent is closed no longer emits stray task events.

packages/agent-core-v2/src/agent/task/taskService.ts

@@ -14,7 +14,7 @@ import {
 } from '#/_base/utils/abort';
 import { setClampedTimeout } from '#/_base/utils/timer';
 import { escapeXml, escapeXmlAttr } from '#/_base/utils/xml-escape';
-import { IEventBus } from '#/app/event/eventBus';
+import { IEventBus, ISessionEventBus } from '#/app/event/eventBus';
 import { Error2, ErrorCodes } from '#/errors';
 import { z } from 'zod';
 import {
@@ -241,6 +241,7 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
     @IAgentScopeContext private readonly scopeContext: IAgentScopeContext,
     @ITaskService private readonly taskService: ITaskService,
     @IEventBus private readonly eventBus: IEventBus,
+    @ISessionEventBus private readonly sessionEventBus: ISessionEventBus,
     @IEventDispatcher private readonly dispatcher: IEventDispatcher,
     @IAgentLifecycleService private readonly agentLifecycle: IAgentLifecycleService,
     @IAgentLoopService private readonly loop: IAgentLoopService,
@@ -853,6 +854,10 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
     return resolveAgentTaskConfig(this.config)?.keepAliveOnExit === true;
   }
 
+  private lifecycleActive(): boolean {
+    return this.sessionEventBus.isAgentActive(this.scopeContext.agentContext);
+  }
+
   async wait(
     taskId: string,
     timeoutMs = 30_000,
@@ -1085,19 +1090,23 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
   }
 
   private recordTaskStarted(info: AgentTaskInfo): void {
-    void this.dispatcher.dispatch(
-      new TaskStarted({ agentId: this.scopeContext.agentId, info }),
-    );
+    if (this.lifecycleActive()) {
+      void this.dispatcher.dispatch(
+        new TaskStarted({ agentId: this.scopeContext.agentId, info }),
+      );
+    }
     this.telemetry.track2('background_task_created', {
       task_id: info.taskId,
       kind: info.kind === 'process' ? 'bash' : info.kind,
     });
   }
 
   private recordTaskTerminated(info: AgentTaskInfo, outputTail?: string): void {
-    void this.dispatcher.dispatch(
-      new TaskTerminated({ agentId: this.scopeContext.agentId, info, outputTail }),
-    );
+    if (this.lifecycleActive()) {
+      void this.dispatcher.dispatch(
+        new TaskTerminated({ agentId: this.scopeContext.agentId, info, outputTail }),
+      );
+    }
     this.telemetry.track2('background_task_completed', {
       task_id: info.taskId,
       kind: info.kind,
@@ -1107,8 +1116,10 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
   }
 
   private async notifyAgentTask(info: AgentTaskInfo): Promise<void> {
+    if (!this.lifecycleActive()) return;
     const context = await this.buildAgentTaskNotificationContext(info);
     if (context === undefined) return;
+    if (!this.lifecycleActive()) return;
     const key = notificationKey(context.origin);
     if (this.deliveredNotificationKeys.has(key)) return;
     const request = new TaskNotificationStepRequest(
@@ -1307,6 +1318,7 @@ export class AgentTaskService extends Disposable implements IAgentTaskService {
   }
 
   private fireNotificationHook(notification: AgentTaskNotification): void {
+    if (!this.lifecycleActive()) return;
     void this.dispatcher.dispatch(
       new TaskNotified({
         agentId: this.scopeContext.agentId,

packages/agent-core-v2/src/app/event/eventBus.ts

@@ -18,6 +18,7 @@ export const IEventBus: ServiceIdentifier<IEventBus> = createDecorator<IEventBus
 export interface ISessionEventBus extends IEventBus {
   activateAgent(agent: AgentContext): void;
   deactivateAgent(agent: AgentContext): void;
+  isAgentActive(agent: AgentContext): boolean;
   sourceOf(event: Event2<any>): AgentContext | undefined;
   onAgent<P extends AgentDomainTrait, E extends Event2<P>>(
     agent: AgentContext,

packages/agent-core-v2/src/app/event/eventBusService.ts

@@ -25,6 +25,10 @@ export class EventBusService extends Service implements ISessionEventBus {
     if (this.agents.get(agent.agentId) === agent) this.agents.delete(agent.agentId);
   }
 
+  isAgentActive(agent: AgentContext): boolean {
+    return this.agents.get(agent.agentId) === agent;
+  }
+
   publish(event: Event2<any>, agent?: AgentContext): void {
     const cls = event.constructor as Event2Class;
     if (cls.agentDomain) {

packages/agent-core-v2/src/session/agentLifecycle/agentLifecycleService.ts

@@ -468,7 +468,6 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
     const reason = abortError('Agent removed');
     let quiescence: IDisposable | undefined;
     try {
-      await phase(() => handle.accessor.get(IAgentTaskService).stopAllOnExit('Session closed'));
       const compaction = handle.accessor.get(IAgentFullCompactionService).compacting;
       const compactionSettled = compaction?.promise.catch(() => undefined) ?? Promise.resolve();
       const prompt = handle.accessor.get(IAgentPromptService);
@@ -486,6 +485,7 @@ export class AgentLifecycleService extends Disposable implements IAgentLifecycle
       await phase(() => {
         quiescence = loop.tryAcquireQuiescence();
       });
+      await phase(() => handle.accessor.get(IAgentTaskService).stopAllOnExit('Session closed'));
       await phase(() => handle.accessor.get(IEventDispatcher).flush());
       await phase(() => managed.runtimeSet.close());
       managed.killSpace();

packages/agent-core-v2/test/agent/task/taskService.test.ts

@@ -637,7 +637,10 @@ describe('AgentTaskService', () => {
     expect(forceStop).not.toHaveBeenCalled();
   });
 
-  it('scope disposal leaves a process running when keepAliveOnExit is set', async () => {
+  it('scope disposal leaves a process running when keepAliveOnExit is set, and its late settle stays silent after deactivation', async () => {
+    const { records } = capturingWire();
+    const track2 = vi.fn();
+    ix.stub(ITelemetryService, { track2 });
     stubTaskConfig({ keepAliveOnExit: true });
     const stdout = new Readable({ read() {} });
     const stderr = new Readable({ read() {} });
@@ -656,7 +659,8 @@ describe('AgentTaskService', () => {
       dispose: vi.fn().mockResolvedValue(undefined),
     } as unknown as IHostProcess;
     const svc = ix.get(IAgentTaskService);
-    svc.registerTask(new ProcessTask(proc, 'keep-running', 'long-running process'));
+    const taskId = svc.registerTask(new ProcessTask(proc, 'keep-running', 'long-running process'));
+    const agentContext = ix.get(IAgentScopeContext).agentContext;
     await Promise.resolve();
 
     disposables.dispose();
@@ -665,10 +669,18 @@ describe('AgentTaskService', () => {
     expect(proc.kill).not.toHaveBeenCalled();
     expect(proc.dispose).not.toHaveBeenCalled();
 
+    eventBus.deactivateAgent(agentContext);
     stdout.push(null);
     stderr.push(null);
     resolveWait(0);
-    await Promise.resolve();
+    await waitForCondition(() => svc.getTask(taskId)?.status === 'completed');
+
+    expect(svc.getTask(taskId)?.status).toBe('completed');
+    expect(records.filter((record) => record['type'] === 'task.terminated')).toHaveLength(0);
+    expect(track2.mock.calls.map(([event]) => event)).toEqual([
+      'background_task_created',
+      'background_task_completed',
+    ]);
   });
 
   it('stop requests force-stop when killGracePeriodMs is zero', async () => {

packages/agent-core-v2/test/session/agentLifecycle/agentLifecycle.test.ts

@@ -783,6 +783,9 @@ describe('AgentLifecycleService', () => {
 
     expect(stopAllOnExit).toHaveBeenCalledWith('Session closed');
     expect(promptDrain).toHaveBeenCalledOnce();
+    expect(stopAllOnExit.mock.invocationCallOrder[0]).toBeGreaterThan(
+      promptDrain.mock.invocationCallOrder[0]!,
+    );
   });
 
   it('remove waits for prompt intake to drain before disposing the agent scope', async () => {