@@ -53,21 +53,28 @@ test('the signal rides the transport context so a built-in-style transport can c
 });
 
 test('aborting a call whose transport ignores the signal still rejects the caller with the typed canceled error', async () => {
+  let lingering: ReturnType<typeof setTimeout> | undefined;
   const client = createAgentDeviceClient(
     {},
     {
       transport: (req) =>
         new Promise<DaemonResponse>((resolve) => {
           // A custom transport that never inspects the context signal: the guard must still settle
-          // the caller's promise when the abort fires.
-          setTimeout(() => resolve({ ok: true, data: { ignored: req.command } }), 10_000);
+          // the caller's promise when the abort fires. The late resolve is cleared once the caller
+          // has been rejected, so the worker keeps no timer alive for its own promise.
+          lingering = setTimeout(
+            () => resolve({ ok: true, data: { ignored: req.command } }),
+            10_000,
+          );
+          lingering.unref?.();
         }),
     },
   );
   const controller = new AbortController();
   const call = client.interactions.press({ ref: '@e12', signal: controller.signal });
   setTimeout(() => controller.abort(), 10);
   await assert.rejects(call, (error: unknown) => canceledWith(error, 'unknown'));
+  if (lingering) clearTimeout(lingering);
 });
 
 test('a signal on one call does not cancel another', async () => {
 
@@ -0,0 +1,108 @@
+/**
+ * #3178: an abort is never a timeout. `handleRequestTimeout` is the one seam that sweeps runner
+ * processes and resets the local daemon, so an abort that settles a request must also disarm that
+ * request's timeout timer. The seam is mocked here — the subject is the transport's timer
+ * discipline, not the sweep — and each case outlives the armed budget, so the assertion proves the
+ * timer was cleared rather than merely beaten to the settle.
+ *
+ * The abort case aborts right after `sendRequest` arms its timer, so the clear is what is tested.
+ * The paired no-signal case lets the same budget expire and must reach the mocked seam, which
+ * makes the abort case's empty-calls assertion evidence instead of an absent hook: delete the
+ * abort path's `clearTimeout` and only the abort case fails.
+ */
+import assert from 'node:assert/strict';
+import { test, vi } from 'vitest';
+import { AppError, isRequestCanceledError } from '@agent-device/kernel/errors';
+import { getRequestSignal } from '@agent-device/host-kit/request';
+import type { DaemonInvokeFn, DaemonRequest, DaemonResponse } from '../../daemon/daemon-request.ts';
+import { createSocketServer, listenNetServer } from '../../daemon/server/transport.ts';
+import { sendRequest } from '../daemon-client-transport.ts';
+import { resolveDaemonPaths } from '../../daemon-resolution.ts';
+import {
+  closeLoopbackServer,
+  skipWhenLoopbackUnavailable,
+  type SkippableTestContext,
+} from '../../__tests__/test-utils/loopback.ts';
+import { mkdtempForTestSync } from '../../__tests__/test-utils/tmp-dir.ts';
+
+const { handleRequestTimeoutCalls } = vi.hoisted(() => ({
+  handleRequestTimeoutCalls: [] as unknown[],
+}));
+
+vi.mock('../daemon-client-timeout.ts', () => ({
+  handleRequestTimeout: (params: unknown) => {
+    handleRequestTimeoutCalls.push(params);
+    return new AppError('COMMAND_FAILED', 'Daemon request timed out', {
+      reason: 'daemon_transport_timeout',
+    });
+  },
+}));
+
+const STATE_PATHS = resolveDaemonPaths(mkdtempForTestSync('agent-device-abort-timeout-'));
+const TIMEOUT_MS = 15;
+// Past the armed budget, so a timer the abort forgot to clear fires inside the case.
+const OUTLIVE_MS = 80;
+
+// A request the daemon never answers: the only things that can end it are the client's abort and
+// the transport's own budget, which is what makes the timer's fate observable.
+function hangingHandler(): DaemonInvokeFn {
+  return async (req: DaemonRequest): Promise<DaemonResponse> => {
+    const signal = getRequestSignal(req.meta?.requestId);
+    return await new Promise<DaemonResponse>((_resolve, reject) => {
+      signal?.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+  };
+}
+
+async function runTimerDiscipline(
+  t: SkippableTestContext,
+  outcome: 'aborted' | 'timed-out',
+): Promise<void> {
+  if (await skipWhenLoopbackUnavailable(t)) return;
+  const aborted = outcome === 'aborted';
+  handleRequestTimeoutCalls.length = 0;
+  const server = createSocketServer(hangingHandler());
+  try {
+    const port = await listenNetServer(server);
+    const controller = new AbortController();
+    const request = sendRequest(
+      { port, token: 't', pid: 1 },
+      {
+        token: 't',
+        command: 'wait',
+        session: 'default',
+        positionals: [],
+        flags: {},
+        meta: { requestId: `req-${outcome}-timeout-timer` },
+      },
+      'socket',
+      STATE_PATHS,
+      TIMEOUT_MS,
+      aborted ? { signal: controller.signal } : {},
+    );
+    if (aborted) {
+      // `sendRequest` armed the timeout timer synchronously by returning; this abort must disarm it.
+      controller.abort();
+      await assert.rejects(request, (error: unknown) => isRequestCanceledError(error));
+    } else {
+      await assert.rejects(
+        request,
+        (error: unknown) =>
+          error instanceof AppError && error.details?.reason === 'daemon_transport_timeout',
+      );
+      assert.equal(handleRequestTimeoutCalls.length, 1);
+    }
+    await new Promise((resolve) => setTimeout(resolve, OUTLIVE_MS));
+    if (aborted) assert.deepEqual(handleRequestTimeoutCalls, []);
+  } finally {
+    await closeLoopbackServer(server);
+  }
+}
+
+test('an abort with a timeout armed clears the timer instead of running the timeout path', async (t) => {
+  await runTimerDiscipline(t, 'aborted');
+});
+
+test('the same budget without a signal reaches the timeout seam', async (t) => {
+  await runTimerDiscipline(t, 'timed-out');
+});