diff --git a/src/index.ts b/src/index.ts
index 6c0c8c9..1ccdb59 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -8,7 +8,7 @@ export { workers } from './worker-pool.ts';
 export { transfer } from './transfer.ts';
 export { assign } from './assign.ts';
 export { roundRobin, leastBusy } from './balancers.ts';
-export type { Task, Balancer, Runner, WorkerHandle, WorkerOptions } from './runner.ts';
+export type { Task, RunResult, Balancer, Runner, WorkerHandle, WorkerOptions } from './runner.ts';
 export {
   shared,
   int8,
diff --git a/src/mo.ts b/src/mo.ts
index 34d8cf1..1067295 100644
--- a/src/mo.ts
+++ b/src/mo.ts
@@ -18,13 +18,13 @@ export type Arg<T> = T | Task<T>;
 type TaskableArgs<A extends unknown[]> = { [K in keyof A]: Arg<A[K]> };
 
 type Moroutine<A extends unknown[], R> = {
-  (...args: A): Task<Awaited<R>>;
-  (...args: TaskableArgs<A>): Task<Awaited<R>>;
+  (...args: A): Task<Awaited<R>, A> & PromiseLike<Awaited<R>>;
+  (...args: TaskableArgs<A>): Task<Awaited<R>, A> & PromiseLike<Awaited<R>>;
 };
 
 type AsyncIterableMoroutine<A extends unknown[], Y> = {
-  (...args: A): Task<AsyncIterable<Y>>;
-  (...args: TaskableArgs<A>): Task<AsyncIterable<Y>>;
+  (...args: A): Task<AsyncIterable<Y>, A> & AsyncIterable<Y>;
+  (...args: TaskableArgs<A>): Task<AsyncIterable<Y>, A> & AsyncIterable<Y>;
 };
 
 type IsNever<T> = [T] extends [never] ? true : false;
diff --git a/src/runner.ts b/src/runner.ts
index 4f41330..c2066cb 100644
--- a/src/runner.ts
+++ b/src/runner.ts
@@ -1,27 +1,28 @@
 import type { Worker } from 'node:worker_threads';
 import type { ChannelOptions } from './channel.ts';
 
-declare const __task__: unique symbol;
+declare const resultBrand: unique symbol;
+declare const argsBrand: unique symbol;
 
-/** A dispatchable task. The type parameter determines the dispatch mode:
- *  - `Task<T>` (non-iterable T) is a `PromiseLike<T>` — await it for a single value.
- *  - `Task<AsyncIterable<T>>` is an `AsyncIterable<T>` — iterate it for a stream.
- *  - `Task` (no param) is the base shape shared by all tasks, useful for balancer signatures. */
-export type Task<T = typeof __task__> = {
+/** An inert task descriptor. Carries the result type `T` and argument types `A`
+ *  at the type level, but is not itself a `PromiseLike` or `AsyncIterable`.
+ *  Dispatch via a {@link Runner} or `await` a live task returned by `mo()`. */
+export type Task<T = unknown, A extends unknown[] = unknown[]> = {
   readonly uid: number;
   readonly id: string;
   readonly args: unknown[];
   worker?: WorkerHandle;
-} & ([T] extends [never]
-  ? PromiseLike<T>
-  : [T] extends [typeof __task__]
-    ? {}
-    : T extends AsyncIterable<infer U>
-      ? AsyncIterable<U>
-      : PromiseLike<T>);
+  /** @internal Type brand for result type inference. Not present at runtime. */
+  readonly [resultBrand]?: T;
+  /** @internal Type brand for argument type inference. Not present at runtime. */
+  readonly [argsBrand]?: A;
+};
+
+/** Resolves the dispatch return type: `AsyncIterable<U>` for streaming tasks, `Promise<T>` otherwise. */
+export type RunResult<T> = T extends AsyncIterable<infer U> ? AsyncIterable<U> : Promise<T>;
 
 type TaskResults<T extends Task<any>[]> = {
-  [K in keyof T]: T[K] extends PromiseLike<infer R> ? R : never;
+  [K in keyof T]: T[K] extends Task<infer R> ? R : never;
 };
 
 /** A load balancing strategy for choosing which worker runs a task. */
@@ -44,10 +45,8 @@ export interface WorkerOptions {
 
 /** A handle to a specific worker in a pool. */
 export interface WorkerHandle {
-  /** Dispatches a streaming task pinned to this worker. */
-  exec<T>(task: Task<AsyncIterable<T>>, opts?: ChannelOptions): AsyncIterable<T>;
-  /** Dispatches a task pinned to this worker. */
-  exec<T>(task: Task<T>): Promise<T>;
+  /** Dispatches a task pinned to this worker. Returns `AsyncIterable<T>` for streaming tasks, `Promise<T>` otherwise. */
+  exec<T>(task: Task<T>, opts?: ChannelOptions): RunResult<T>;
   /** The underlying worker thread. */
   readonly thread: Worker;
   /** Number of currently in-flight tasks on this worker. */
@@ -61,12 +60,10 @@ export interface WorkerHandle {
  * @returns `Promise<T>` for a single task, `Promise<[...results]>` for a batch, or `AsyncIterable<T>` for a streaming task.
  */
 export type Runner = {
-  /** Dispatches a streaming task and returns an async iterable of yielded values. */
-  <T>(task: Task<AsyncIterable<T>>, opts?: ChannelOptions): AsyncIterable<T>;
-  /** Dispatches a single task and returns its result. */
-  <T>(task: Task<T>): Promise<T>;
   /** Dispatches a batch of tasks in parallel and returns all results. */
   <T extends Task<any>[]>(tasks: [...T]): Promise<TaskResults<T>>;
+  /** Dispatches a task. Returns `AsyncIterable<T>` for streaming tasks, `Promise<T>` otherwise. */
+  <T>(task: Task<T>, opts?: ChannelOptions): RunResult<T>;
   /** AbortSignal that fires when the pool starts disposing. */
   readonly signal: AbortSignal;
   /** Read-only array of worker handles, one per pool worker. */