fix: complete shutdown and ellipsis cleanup

Guard cron delivery continuations after runtime disposal, cover the awaited injection race, and use Unicode ellipses in the remaining tool output.

Remove unrelated sorting and test-timeout changes from the PR.

Refs #248

Author: elkaix

apps/pythinker-code/src/tui/components/messages/tool-call.ts

@@ -813,7 +813,7 @@ export class ToolCallComponent extends Container {
     if (this.result !== undefined || text.length === 0) return;
     this.liveOutput += text;
     if (this.liveOutput.length > MAX_LIVE_OUTPUT_CHARS) {
-      this.liveOutput = `[...truncated]\n${this.liveOutput.slice(
+      this.liveOutput = `[…truncated]\n${this.liveOutput.slice(
         this.liveOutput.length - MAX_LIVE_OUTPUT_CHARS,
       )}`;
     }
@@ -2130,7 +2130,7 @@ export class ToolCallComponent extends Container {
       const elapsedSeconds =
         startedAtMs === undefined ? 0 : Math.max(0, Math.floor((Date.now() - startedAtMs) / 1000));
       const target = filePath.length > 0 ? ` for ${filePath}` : '';
-      const progress = `Preparing changes${target}... ${formatByteSize(bytes)} · ${formatElapsed(
+      const progress = `Preparing changes${target}… ${formatByteSize(bytes)} · ${formatElapsed(
         elapsedSeconds,
       )} elapsed`;
       this.addChild(new Text(currentTheme.dim(progress), 2, 0));

apps/pythinker-code/test/tui/components/messages/tool-call.test.ts

@@ -254,6 +254,24 @@ describe('ToolCallComponent', () => {
     expect(out).toContain('line2');
   });
 
+  it('uses a Unicode ellipsis when truncating live Bash output', () => {
+    const component = new ToolCallComponent(
+      {
+        id: 'call_shell_live_truncated',
+        name: 'Bash',
+        args: { command: 'printf output' },
+      },
+      undefined,
+    );
+
+    component.setExpanded(true);
+    component.appendLiveOutput('x'.repeat(50_001));
+
+    const out = strip(component.render(1000).join('\n'));
+    expect(out).toContain('[…truncated]');
+    expect(out).not.toContain('[...truncated]');
+  });
+
   it('clears live Bash output when the final result arrives', () => {
     const component = new ToolCallComponent(
       {
@@ -1751,7 +1769,7 @@ describe('ToolCallComponent', () => {
     const out = strip(component.render(100).join('\n'));
     expect(out).toContain('Using Edit');
     expect(out).toContain('foo.ts');
-    expect(out).toContain('Preparing changes for foo.ts...');
+    expect(out).toContain('Preparing changes for foo.ts…');
     expect(out).toContain('4s elapsed');
     expect(out).toMatch(/\d+(?:\.\d+)? (?:B|KB|MB)/);
     expect(out).not.toContain('old20');

apps/vscode/webview-ui/src/components/SessionList.tsx

@@ -132,7 +132,8 @@ export function SessionList({ onClose }: SessionListProps) {
   const groupedSessions = useMemo(() => {
     const q = searchQuery.trim().toLowerCase();
     const filtered = q ? sessions.filter((s) => cleanSystemTags(s.brief).toLowerCase().includes(q)) : sessions;
-    const sorted = [...filtered].toSorted((a, b) => (sortOrder === "recent" ? b.updatedAt - a.updatedAt : a.updatedAt - b.updatedAt));
+    // oxlint-disable-next-line eslint-plugin-unicorn/no-array-sort -- The copied array is safe to sort in place.
+    const sorted = [...filtered].sort((a, b) => (sortOrder === "recent" ? b.updatedAt - a.updatedAt : a.updatedAt - b.updatedAt));
 
     const now = new Date();
     // Calendar-day arithmetic, not fixed 24h offsets — a DST change makes a

packages/agent-core-v2/src/features/cron/cronAgentRuntime.ts

@@ -161,6 +161,7 @@ function deliverFire(
   runtime: AgentRuntimeContext<CronModelState>,
   task: CronTask,
   context: { readonly coalescedCount: number; readonly firedAt: number },
+  isDisposed: () => boolean,
 ): Promise<boolean> {
   const origin: CronJobOrigin = {
     kind: 'cron_job',
@@ -181,11 +182,14 @@ function deliverFire(
   try {
     launched = runtime.get(IAgentPromptService).inject(message);
   } catch (error) {
-    debugLog(runtime, `steer threw for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+    if (!isDisposed()) {
+      debugLog(runtime, `steer threw for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
     return Promise.resolve(false);
   }
   return launched.then(
     () => {
+      if (isDisposed()) return false;
       void runtime.dispatch(new CronFired({ origin, prompt: task.prompt }));
       telemetryOf(runtime).track2(CRON_FIRED, {
         recurring: task.recurring !== false,
@@ -196,7 +200,9 @@ function deliverFire(
       return true;
     },
     (error: unknown) => {
-      debugLog(runtime, `steer launch rejected for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+      if (!isDisposed()) {
+        debugLog(runtime, `steer launch rejected for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+      }
       return false;
     },
   );
@@ -207,6 +213,7 @@ async function processDue(
   state: CronEffectState,
   task: CronTask,
   now: number,
+  isDisposed: () => boolean,
 ): Promise<void> {
   if (state.inFlight.has(task.id)) return;
   let parsed: ParsedCronExpression;
@@ -242,13 +249,15 @@ async function processDue(
   const firedAt = state.clocks.wallNow();
   let delivered = false;
   try {
-    delivered = await deliverFire(runtime, task, { coalescedCount, firedAt });
+    delivered = await deliverFire(runtime, task, { coalescedCount, firedAt }, isDisposed);
   } catch (error) {
-    debugLog(runtime, `deliverDue threw for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+    if (!isDisposed()) {
+      debugLog(runtime, `deliverDue threw for task ${task.id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
   } finally {
-    state.inFlight.delete(task.id);
+    if (!isDisposed()) state.inFlight.delete(task.id);
   }
-  if (!delivered) return;
+  if (isDisposed() || !delivered) return;
   if (task.recurring === false || isStaleAt(runtime, task, firedAt)) {
     const removed = removeTasks(runtime, [task.id]);
     state.lastSeenAt.delete(task.id);
@@ -277,7 +286,9 @@ async function tickCron(
   if (readCronConfig(config).disabled || runtime.getState().size === 0) return;
   if (runtime.get(IAgentLoopService).status().state === 'running') return;
   const now = state.clocks.wallNow();
-  await Promise.all([...runtime.getState().values()].map((task) => processDue(runtime, state, task, now)));
+  await Promise.all(
+    [...runtime.getState().values()].map((task) => processDue(runtime, state, task, now, isDisposed)),
+  );
 }
 
 const cronEffects = fromCallback(({

packages/agent-core-v2/test/features/cron/sessionCron.test.ts

@@ -2,14 +2,20 @@ import { describe, expect, it } from 'vitest';
 
 import { DisposableStore } from '#/_base/di/lifecycle';
 import { createServices } from '#/_base/di/test';
-import type { AgentContext } from '#/agent/agentContext/agentContext';
+import { IAgentLoopService } from '#/agent/loop/loop';
+import { IAgentPromptService } from '#/agent/prompt/prompt';
+import type { DurableAgentRuntimeParticipant } from '#/agent/runtime/agentRuntime';
 import { AgentRuntimeSet } from '#/agent/runtime/agentRuntimeSet';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IConfigService } from '#/app/config/config';
+import { ITelemetryService } from '#/app/telemetry/telemetry';
 import { DEFAULT_CRON_CONFIG } from '#/features/cron/configSection';
 import { AgentCron, cronAgentRuntimeProvider } from '#/features/cron/cronAgentRuntime';
-import { CronCursor } from '#/features/cron/cronOps';
+import { CronCursor, type CronModelState } from '#/features/cron/cronOps';
+import { IEventDispatcher } from '#/state/eventDispatcher';
 
+import { stubAgentContext } from '../../agent/agentContext/stubs';
+import { stubLoopWithHooks } from '../../agent/loop/stubs';
 import {
   createTestAgent,
   InMemoryWireRecordPersistence,
@@ -28,48 +34,80 @@ async function bootCronContext(options: TestAgentOptions = {}): Promise<TestAgen
 
 describe('session cron wire persistence', () => {
   it('settles an in-flight tick without reading services after close', async () => {
-    let releaseReady!: () => void;
-    const ready = new Promise<void>((resolve) => { releaseReady = resolve; });
-    let markTickStarted!: () => void;
-    const tickStarted = new Promise<void>((resolve) => { markTickStarted = resolve; });
-    let readyReads = 0;
+    let releaseInject!: () => void;
+    const injection = new Promise<undefined>((resolve) => { releaseInject = () => { resolve(undefined); }; });
+    let markInjectStarted!: () => void;
+    const injectStarted = new Promise<void>((resolve) => { markInjectStarted = resolve; });
     let closed = false;
+    let postCloseReads = 0;
+    const recordRead = (): void => {
+      if (closed) postCloseReads += 1;
+    };
     const disposables = new DisposableStore();
     const services = createServices(disposables, {
       additionalServices: (reg) => {
         reg.definePartialInstance(IConfigService, {
-          get ready() {
-            readyReads += 1;
-            if (readyReads === 2) markTickStarted();
-            return ready;
-          },
+          ready: Promise.resolve(),
           get: <T>() => {
-            if (closed) throw new Error('config read after close');
-            return DEFAULT_CRON_CONFIG as T;
+            recordRead();
+            return { ...DEFAULT_CRON_CONFIG, noJitter: true, manualTick: true } as T;
+          },
+        });
+        reg.defineInstance(IAgentLoopService, stubLoopWithHooks());
+        reg.definePartialInstance(IAgentPromptService, {
+          inject: () => {
+            markInjectStarted();
+            return injection;
           },
         });
+        reg.definePartialInstance(IEventDispatcher, {
+          dispatch: async () => { recordRead(); },
+        });
+        reg.definePartialInstance(ITelemetryService, {
+          track2: () => { recordRead(); },
+        });
       },
     });
-    const agent = { agentId: 'main', generation: 1, space: {} } as AgentContext;
+    const agent = stubAgentContext('main');
     const runtimes = new AgentRuntimeSet(agent, services);
     runtimes.apply({
       definition: AgentCron,
       provider: cronAgentRuntimeProvider,
       generation: 1,
       active: true,
     });
-    runtimes.attachDurable({ attach: () => ({ dispose: () => {} }) });
-
-    const restoring = runtimes.restore();
-    const ticking = runtimes.resolve(AgentCron).tick();
-    await tickStarted;
-    await runtimes.close();
-    closed = true;
-    disposables.dispose();
-    releaseReady();
-
-    await expect(ticking).resolves.toBeUndefined();
-    await expect(restoring).resolves.toBeUndefined();
+    let participant: DurableAgentRuntimeParticipant<CronModelState> | undefined;
+    runtimes.attachDurable({
+      attach: (attached) => {
+        participant = attached;
+        return { dispose: () => {} };
+      },
+    });
+
+    try {
+      await runtimes.restore();
+      if (participant === undefined) throw new Error('Cron runtime was not attached');
+      const now = Date.now();
+      participant.commit(new Map([['deadbeef', {
+        id: 'deadbeef',
+        cron: '* * * * *',
+        prompt: 'fire after wait',
+        recurring: true,
+        createdAt: now - 120_000,
+      }]]));
+
+      const ticking = runtimes.resolve(AgentCron).tick();
+      await injectStarted;
+      await runtimes.close();
+      closed = true;
+      releaseInject();
+
+      await expect(ticking).resolves.toBeUndefined();
+      expect(postCloseReads).toBe(0);
+    } finally {
+      await runtimes.close();
+      disposables.dispose();
+    }
   });
 
   it('writes cron ops as durable wire records and rebuilds the task table on replay', async () => {

packages/agent-core-v2/test/features/tower/store.test.ts

@@ -587,7 +587,7 @@ describe('merge gate', () => {
     await store.merge(consumer.branch);
     const state = await store.load();
     expect(state.missions.find((m) => m.id === consumer.id)?.status).toBe('merged');
-  }, 15_000);
+  });
 
   it('refuses files outside the mission scope until the tower widens it', async () => {
     const mission = await setupMission({
@@ -651,7 +651,7 @@ describe('merge gate', () => {
     expect(conflictsWith).toEqual([
       { branch: second.branch, files: ['src/a/shared.ts'] },
     ]);
-  }, 15_000);
+  });
 
   it('closes a zero-diff survey with a noop merge — no review, no git ceremony', async () => {
     const [mission] = await store.plan([
@@ -754,7 +754,7 @@ describe('merge gate', () => {
 
     const after = await store.merge(third!.branch);
     expect(after.conflictsWith.map((c) => c.branch)).not.toContain(second!.branch);
-  }, 15_000);
+  });
 });
 
 describe('updateMission', () => {

packages/agent-gateway/test/fs-watch.e2e.test.ts

@@ -210,7 +210,7 @@ describe('WS fs watch (agent-gateway)', () => {
 
     writeFileSync(join(workspace, 'src', 'instant.ts'), 'export const i = 1;\n');
 
-    const ev = await receiveType(conn, 'event.fs.changed', 10_000);
+    const ev = await receiveType(conn, 'event.fs.changed', 3000);
     expect(ev.session_id).toBe(sid);
     const payload = ev.payload as { changes: Array<{ path: string }> };
     expect(payload.changes.some((c) => c.path === 'src/instant.ts' || c.path === 'src')).toBe(true);