test(agent-core-v2): dispose task fixtures before deleting their session dir (#216)

## Related Issue

No issue. Found when a CI shard failed on an unrelated PR with
`ENOTEMPTY: directory not empty, rmdir
'/tmp/pythinker-bg-limit-agent-*/sessions/test-workspace/test-session'`.

## Problem

Five `AgentTaskService` cases create a temporary session directory and
an agent context over it, then delete the directory in their `finally`
block. None of them disposed the context first, so the context was still
writing session state into that directory while the delete walked it. On
a loaded CI machine the two race and the run fails with `ENOTEMPTY`. The
tests also leaked six agent contexts per run.

One case already worked around a symptom of this by awaiting
`ISessionMetadata.ready`; the other four had nothing.

## What changed

- New `cleanupSessionDir(sessionDir, ...contexts)` test helper: disposes
every context, then removes the directory with `fs.rm`'s own
`maxRetries` / `retryDelay` — the documented remedy for `ENOTEMPTY` /
`EBUSY` / `EPERM` from a concurrent writer.
- All five cases now hoist their fixture above the `try` and clean up
through the helper. No production code changes; no changeset, since
nothing user-visible changes.

## Verification

- Instrumented the helper once locally: exactly 6 contexts are now
disposed per run of this file, none of which were disposed before.
- `test/agent/task/taskManager.test.ts` — 48 passed, 3 consecutive runs
- `pnpm --filter @pymodel/agent-core-v2 exec vitest run` — 347 files,
5,723 tests passed
- `typecheck`, `tsgo`, `check-no-comments`, oxlint — exit 0

## Checklist

- [x] I have read the
[CONTRIBUTING](https://github.com/PyModel/pythinker-code/blob/main/CONTRIBUTING.md)
document.
- [x] I have linked a related issue (external PRs: the issue must have a
maintainer's `/approve`).
- [x] I have added tests that prove my feature works.
- [x] Ran `gen-changesets` skill, or this PR needs no changeset.
- [x] Ran `gen-docs` skill, or this PR needs no doc update.


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Tests**
  * Improved cleanup of temporary session data after test runs.
  * Ensured test-agent contexts are properly disposed of.
* Updated session-based tests to use separate reader and writer fixtures
where needed.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: elkaix

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

@@ -66,6 +66,14 @@ function createAgentTaskService(options: {
   };
 }
 
+async function cleanupSessionDir(
+  sessionDir: string,
+  ...contexts: readonly (TestAgentContext | undefined)[]
+): Promise<void> {
+  for (const ctx of contexts) await ctx?.dispose();
+  await rm(sessionDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
+}
+
 function registerProcess(
   manager: IAgentTaskService,
   proc: IHostProcess,
@@ -681,8 +689,8 @@ describe('AgentTaskService', () => {
 
   it('stops appending persisted foreground output once the output limit trips', async () => {
     const sessionDir = await mkdtemp(join(tmpdir(), 'pythinker-bg-limit-fg-'));
+    const { ctx, manager } = createAgentTaskService({ sessionDir });
     try {
-      const { manager } = createAgentTaskService({ sessionDir });
       const chunks = Array.from({ length: 20 }, () => 'x'.repeat(MiB));
       const { proc } = sigtermIgnoringProcess(chunks);
 
@@ -701,14 +709,14 @@ describe('AgentTaskService', () => {
       expect(info).toMatchObject({ status: 'killed' });
       expect(output.outputSizeBytes).toBeLessThanOrEqual(LIMIT_BYTES);
     } finally {
-      await rm(sessionDir, { recursive: true, force: true });
+      await cleanupSessionDir(sessionDir, ctx);
     }
   });
 
   it('stops appending persisted output once the output limit trips for a detached process task', async () => {
     const sessionDir = await mkdtemp(join(tmpdir(), 'pythinker-bg-limit-bg-'));
+    const { ctx, manager } = createAgentTaskService({ sessionDir });
     try {
-      const { manager } = createAgentTaskService({ sessionDir });
       const chunks = Array.from({ length: 20 }, () => 'x'.repeat(MiB));
       const { proc } = sigtermIgnoringProcess(chunks);
 
@@ -727,14 +735,14 @@ describe('AgentTaskService', () => {
       expect(info?.stopReason ?? '').toMatch(/output limit/i);
       expect(output.outputSizeBytes).toBeLessThanOrEqual(LIMIT_BYTES);
     } finally {
-      await rm(sessionDir, { recursive: true, force: true });
+      await cleanupSessionDir(sessionDir, ctx);
     }
   });
 
   it('does not cap a detached subagent result larger than the process output limit', async () => {
     const sessionDir = await mkdtemp(join(tmpdir(), 'pythinker-bg-limit-agent-'));
+    const { ctx, manager } = createAgentTaskService({ sessionDir });
     try {
-      const { manager } = createAgentTaskService({ sessionDir });
       const result = 'y'.repeat(20 * MiB);
       const taskId = manager.registerTask(
         agentTask(Promise.resolve({ result }), 'big subagent result'),
@@ -747,7 +755,7 @@ describe('AgentTaskService', () => {
       expect(info).toMatchObject({ status: 'completed' });
       expect(output.outputSizeBytes).toBe(Buffer.byteLength(result));
     } finally {
-      await rm(sessionDir, { recursive: true, force: true });
+      await cleanupSessionDir(sessionDir, ctx);
     }
   });
 
@@ -1079,16 +1087,19 @@ describe('AgentTaskService', () => {
 
   it('persists graceful process shutdown as killed when stop was requested', async () => {
     const sessionDir = await mkdtemp(join(tmpdir(), 'pythinker-bg-stop-race-'));
+    const writerFixture = createAgentTaskService({ sessionDir });
+    const writer = writerFixture.manager;
+    let readerFixture: TaskServiceFixture | undefined;
     try {
-      const writer = createAgentTaskService({ sessionDir }).manager;
       const { proc, resolve } = manuallyResolvedProcess();
       const taskId = registerProcess(writer, proc, 'sleep 60', 'persisted race');
 
       const stopPromise = writer.stop(taskId, 'user requested');
       resolve(0);
       await stopPromise;
 
-      const reader = createAgentTaskService({ sessionDir }).manager;
+      readerFixture = createAgentTaskService({ sessionDir });
+      const reader = readerFixture.manager;
       await reader.loadFromDisk();
 
       expect(reader.getTask(taskId)).toMatchObject({
@@ -1098,7 +1109,7 @@ describe('AgentTaskService', () => {
         stopReason: 'user requested',
       });
     } finally {
-      await rm(sessionDir, { recursive: true, force: true });
+      await cleanupSessionDir(sessionDir, writerFixture.ctx, readerFixture?.ctx);
     }
   });
 
@@ -1285,15 +1296,15 @@ describe('AgentTaskService', () => {
 
   it('getTask on an unknown id does not create persisted state', async () => {
     const sessionDir = await mkdtemp(join(tmpdir(), 'pythinker-bg-mgr-missing-'));
+    const { ctx, manager, persistence } = createAgentTaskService({ sessionDir });
     try {
-      const { ctx, manager, persistence } = createAgentTaskService({ sessionDir });
 
       expect(manager.getTask('bash-bogusss0')).toBeUndefined();
 
       expect(await persistence!.listTasks()).toEqual([]);
       await ctx.get(ISessionMetadata).ready;
     } finally {
-      await rm(sessionDir, { recursive: true, force: true });
+      await cleanupSessionDir(sessionDir, ctx);
     }
   });