diff --git a/.agents/skills/harden-pr/LEDGER.md b/.agents/skills/harden-pr/LEDGER.md
index ad683c2..5a7a7ab 100644
--- a/.agents/skills/harden-pr/LEDGER.md
+++ b/.agents/skills/harden-pr/LEDGER.md
@@ -19,6 +19,7 @@ By-design or false-positive findings — do not re-raise.
 - **[correctness]** `packages/alpine/src/index.ts` multi-child `x-layer-outlet` template — by-design; Alpine `<template>` loops (`x-for`/`x-if`) require a single root element; outlet matches that contract (document in alpine.mdx).
 - **[docs]** `apps/docs/content/adapters/index.mdx` Alpine footnote `⁷` vs `docs/architecture.md` `⁸` — by-design; each matrix numbers footnotes for its own footnote set (architecture also has Lit `⁷`).
 - **[correctness]** `void group.open(...)` samples after Option C — false positive for unhandledrejection; `#rejectCancel` already `void layer.promise.promise.catch(() => {})`. Awaiters still need `isLayerCancelledError`.
+- **[docs]** `packages/core/skills/layers/SKILL.md` omit listing `ResponseArgTuple`/`DismissAllArgs`/… in the public utility row — by-design; cite `EndArgs` only (lean advertise).
 
 ## Deferred
 
diff --git a/.changeset/end-args-void-ergonomics.md b/.changeset/end-args-void-ergonomics.md
new file mode 100644
index 0000000..674927d
--- /dev/null
+++ b/.changeset/end-args-void-ergonomics.md
@@ -0,0 +1,5 @@
+---
+"@stainless-code/layers": patch
+---
+
+`EndArgs`: omit dismiss/end response when `undefined extends R` (twin of `PayloadArg`). Applies to `call.end`/`dismiss`, stack `dismiss`/`dismissAll`/`cancelQueued`, and handle `dismiss`/`cancelQueued`. **Type tighten:** handle dismiss/cancelQueued are no longer always-optional — bare omit errors when `R` does not admit `undefined`. Adapter skills note void omit.
diff --git a/apps/docs/content/concepts/blockers.mdx b/apps/docs/content/concepts/blockers.mdx
index 8529809..a822dd4 100644
--- a/apps/docs/content/concepts/blockers.mdx
+++ b/apps/docs/content/concepts/blockers.mdx
@@ -23,11 +23,11 @@ stack.addBlocker(fn: (layer: LayerState) => boolean | Promise<boolean>): () => v
 Predicates may be async; `dismiss` awaits them. A veto **rejects** the attempt (layer stays open; caller re-issues after confirming) rather than deferring the caller's `Promise<R>`. Confirm UI is the consumer's own layer — core never opens UI.
 
 ```ts
-call.end(response, opts?: { force?: boolean }): Promise<boolean>;   // return = "did it dismiss?"
-call.dismiss(response, opts?: { force?: boolean }): Promise<boolean>;
+call.end(...args: EndArgs<R>): Promise<boolean>; // return = "did it dismiss?"
+call.dismiss(...args: EndArgs<R>): Promise<boolean>;
 ```
 
-Return value = "did it dismiss?". `{ force: true }` bypasses blockers. Repeat `end`/`dismiss` while `dismissing` dedupes to the in-flight promise; `force` wins immediately. Predicate throw/reject = veto (fail-closed; dev warning).
+Omit the response when `undefined extends R` (e.g. void toasts). Return value = "did it dismiss?". `{ force: true }` bypasses blockers — pass `end(response, { force: true })` or `end(undefined, { force: true })` when the response is optional. Repeat `end`/`dismiss` while `dismissing` dedupes to the in-flight promise; `force` wins immediately. Predicate throw/reject = veto (fail-closed; dev warning).
 
 ## dismissing flag
 
@@ -37,7 +37,7 @@ Gate runs **before** exit transition: allowed → resolve promise, `phase: "dism
 
 ## dismissAll modes
 
-`stack.dismissAll(response, opts?: { mode? })` is async:
+`stack.dismissAll(...args: DismissAllArgs<R>)` is async (omit response when `undefined extends R`):
 
 | mode                      | behavior                                          |
 | ------------------------- | ------------------------------------------------- |
diff --git a/apps/docs/content/concepts/overview.mdx b/apps/docs/content/concepts/overview.mdx
index 32a92f7..e75a359 100644
--- a/apps/docs/content/concepts/overview.mdx
+++ b/apps/docs/content/concepts/overview.mdx
@@ -16,7 +16,7 @@ LayerClient ──┬── LayerStack (named, ordered) ── Layer[]
 
 1. **Declare** — `layerOptions<P, R>({ stack, key, ... })` brands the <Tooltip tip="The logical identity of a layer; find/upsert/gcTime operate on its signature.">key</Tooltip> with a `DataTag` so `open()` infers the response type.
 2. **Observe** — subscribe to a stack snapshot; adapters bind `LayerStack.subscribe` / `getSnapshot` to UI reactivity.
-3. **Call** — a wired handle's `open(payload)` (or bag-form `client.open({ ...options, payload })`); resolution happens when something calls `call.end(response)` or `call.dismiss(response)`.
+3. **Call** — a wired handle's `open(payload)` (or bag-form `client.open({ ...options, payload })`); resolution happens when something calls `call.end` / `call.dismiss` (response optional when `undefined extends R`).
 
 ## Package boundary
 
diff --git a/apps/docs/content/guides/dismissal-blockers.mdx b/apps/docs/content/guides/dismissal-blockers.mdx
index a02d0c1..6eae69b 100644
--- a/apps/docs/content/guides/dismissal-blockers.mdx
+++ b/apps/docs/content/guides/dismissal-blockers.mdx
@@ -33,7 +33,7 @@ Both return a disposer. Predicates may be async; `dismiss` awaits them.
 `call.end` and `call.dismiss` return `Promise<boolean>` — `true` if dismissed, `false` if vetoed:
 
 ```tsx
-const didDismiss = await call.dismiss(undefined);
+const didDismiss = await call.dismiss(); // void-R: omit the response
 if (!didDismiss) {
   // show confirm UI — your own layer, not opened by core
 }
@@ -44,6 +44,7 @@ Bypass blockers with `{ force: true }`:
 ```ts
 await call.end(response, { force: true });
 await call.dismiss(response, { force: true });
+// void-R: await call.end(undefined, { force: true });
 ```
 
 While blockers evaluate, `dismissing` is `true` on the layer state — disable close buttons during async confirm:
@@ -60,7 +61,7 @@ function Editor({ call, dismissing }: LayerComponentProps<void, void>) {
 
 ## dismissAll modes
 
-`stack.dismissAll(response, opts?)` is async:
+`stack.dismissAll(...args)` is async (omit response for void-R):
 
 | Mode | Behavior |
 | ---- | -------- |
@@ -70,6 +71,7 @@ function Editor({ call, dismissing }: LayerComponentProps<void, void>) {
 
 ```ts
 await stack.dismissAll(undefined, { mode: "stopAtBlocked" });
+// void-R + default mode: await stack.dismissAll();
 ```
 
 Default mode is configurable via `StackOptions.dismissAllMode` or `LayerClientOptions.defaultStackOptions`.
diff --git a/apps/docs/content/guides/error-handling.mdx b/apps/docs/content/guides/error-handling.mdx
index cf62865..a356425 100644
--- a/apps/docs/content/guides/error-handling.mdx
+++ b/apps/docs/content/guides/error-handling.mdx
@@ -19,7 +19,7 @@ The promise rejects when:
 2. **`validate` fails** — `PayloadValidationError`
 3. **System teardown** — `LayerCancelledError` from `cancelAll` (parent dismiss drain, layer-group dispose, host disconnect)
 
-User dismiss / `dismissAll(response)` still **resolves** with `R` (including `undefined` for `R = void`). Narrow cancel with `isLayerCancelledError` — do not treat it as the user choosing a falsy response.
+User `dismiss` / `dismissAll` complete `open()` with `R` (including `undefined` for void) — they resolve, they do not reject. Narrow cancel with `isLayerCancelledError`; do not treat cancel as a falsy user choice.
 
 Dismissal during `pending` resolves with the dismissal response (the in-flight `loadFn` is aborted via `AbortController`); it does not reject.
 
diff --git a/apps/docs/content/reference/core-api.mdx b/apps/docs/content/reference/core-api.mdx
index 9aa6416..22911c9 100644
--- a/apps/docs/content/reference/core-api.mdx
+++ b/apps/docs/content/reference/core-api.mdx
@@ -69,11 +69,11 @@ class LayerStack {
 
   find(key: LayerKey): Layer | undefined; // topmost same-key (findLast)
   getLayer(id: string): Layer | undefined;
-  dismiss(layer, response?, opts?: DismissOptions): Promise<boolean>;
-  dismissAll(response?, opts?: DismissAllOptions): Promise<void>;
+  dismiss(layer, ...args: EndArgs<R>): Promise<boolean>;
+  dismissAll(...args: DismissAllArgs<R>): Promise<void>;
   cancelAll(opts?: { reason?: LayerCancelReason }): Promise<void>;
   addBlocker(fn: StackBlockerFn): () => void;
-  cancelQueued(key: LayerKey, response, opts?: { id?: string }): boolean;
+  cancelQueued(key: LayerKey, ...args: CancelQueuedArgs<R>): boolean;
   settle(layer): void;
   setRunning(layer, running: boolean): void;
   update(layer, patch: Partial<P>): void;
@@ -86,8 +86,8 @@ class LayerStack {
 | `getQueuedSnapshot` | Serial-scope queue — layers waiting behind the occupying layer                                                            |
 | `subscribe`         | Register for snapshot changes (batched via `notifyManager`)                                                               |
 | `find`              | Topmost mounted layer for a logical key (key signature; `findLast`)                                                       |
-| `dismiss`           | Resolve one layer; returns whether dismissal succeeded (blockers may veto)                                                |
-| `cancelQueued`      | Resolve a serial `queued` layer without mounting; omit `{ id }` → FIFO head for the key, `{ id }` → exact queued instance |
+| `dismiss`           | Resolve one layer; response optional when `undefined extends R` (`EndArgs`); blockers may veto                            |
+| `cancelQueued`      | Resolve a serial `queued` layer without mounting; same response gate; omit `{ id }` → FIFO, `{ id }` → exact match      |
 | `addBlocker`        | Stack-scoped dismiss gate; returns a disposer                                                                             |
 
 ## StackNotifyEvent
@@ -195,7 +195,7 @@ function assertLayerKey(key: unknown): asserts key is LayerKey;
 
 ## Layer cancel errors
 
-System teardown (`cancelAll`, parent-dismiss child drain, group dispose, host disconnect) rejects `open()` with `LayerCancelledError`. User `dismiss` / `dismissAll(response)` still resolve with `R`. See [Error handling](/guides/error-handling).
+System teardown (`cancelAll`, parent-dismiss child drain, group dispose, host disconnect) rejects `open()` with `LayerCancelledError`. User `dismiss` / `dismissAll` complete `open()` with `R` — they do not reject. See [Error handling](/guides/error-handling).
 
 ```ts
 type LayerCancelReason =
@@ -228,10 +228,10 @@ function createLayer<V extends Validator<unknown>, R, …>(
 ```
 
 ```ts
-const confirm = createLayer(confirmOptions, client);
+const confirm = createLayer(confirmOptions, client); // R = boolean
 const ok = await confirm.open({ title: "Remove?" });
 confirm.dismiss(false);
-confirm.cancelQueued(undefined, { id: "queued-id" }); // optional exact match
+confirm.cancelQueued(false, { id: "queued-id" }); // response required for boolean R
 ```
 
 <AutoTypeTable
@@ -254,7 +254,9 @@ function createCallContext<P, R, RootProps = unknown>(
 ): LayerCallContext<P, R, RootProps>;
 ```
 
-`LayerCallContext` exposes `end`, `dismiss`, `addBlocker`, `update`, `setRunning`, `settle`, plus read-only `ended`, `index`, `stackSize`, `root`, `stackId`, and `layerId`.
+`LayerCallContext` exposes `end`, `dismiss`, `addBlocker`, `update`, `setRunning`, `settle`, plus read-only `ended`, `index`, `stackSize`, `root`, `stackId`, and `layerId`. Omit the response on `end`/`dismiss` when `undefined extends R` (`EndArgs` — same gate as `PayloadArg` / `.open()`).
+
+<AutoTypeTable path="../../packages/core/src/types.ts" name="EndArgs" />
 
 <AutoTypeTable
   path="../../packages/core/src/types.ts"
diff --git a/apps/docs/content/reference/migration.mdx b/apps/docs/content/reference/migration.mdx
index c21f35c..dcda2ae 100644
--- a/apps/docs/content/reference/migration.mdx
+++ b/apps/docs/content/reference/migration.mdx
@@ -80,6 +80,20 @@ On `LayerStack`: `cancelQueued(key, response, opts?: { id? })`. Omit `id` → fi
 | Queued stack    | `useQueuedStack`                   | `injectQueuedStack`              | `useQueuedStack`         | `createQueuedStack`      |
 | Queued per-key  | `useLayerQueuedState`              | `injectLayerQueuedState`         | `createLayerQueuedState` | `createLayerQueuedState` |
 
+## 0.x — omit dismiss response when void
+
+Toasts and other void-result layers no longer need `call.end(undefined)`. Omit the response whenever `undefined extends R` — same rule as omitting `.open()`'s payload (`PayloadArg` / `EndArgs`). Applies to `call.end`/`dismiss`, stack `dismiss`/`dismissAll`/`cancelQueued`, and handle `dismiss`/`cancelQueued`.
+
+<Diff
+  lang="ts"
+  old={`await call.end(undefined); // void toast`}
+  new={`await call.end();`}
+/>
+
+**Type tighten:** `LayerHandle.dismiss` / `cancelQueued` used to accept a missing response for every `R`. Bare `handle.dismiss()` is now an error when `R` does not admit `undefined` (pass `true`/`false` for confirms).
+
+`LayerClient.dismissAll` / `LayerGroup.dismissAll` stay loosely typed (`response?: unknown`) — stacks on a client are heterogeneous.
+
 :::note[Pin in production]
 Lock `@stainless-code/layers` and your adapter package in `package.json`. Review the changelog before upgrading.
 :::
diff --git a/apps/docs/recipes/progress/angular.ts b/apps/docs/recipes/progress/angular.ts
index a6e5189..7a3cea6 100644
--- a/apps/docs/recipes/progress/angular.ts
+++ b/apps/docs/recipes/progress/angular.ts
@@ -75,7 +75,7 @@ export class AppComponent {
       this.c.stack.update(layer, { percent });
       if (percent >= 100) {
         clearInterval(interval);
-        void this.c.stack.dismiss(layer, undefined as void).then(() => {
+        void this.c.stack.dismiss(layer).then(() => {
           this.status.set("complete");
         });
       }
diff --git a/apps/docs/recipes/progress/preact.tsx b/apps/docs/recipes/progress/preact.tsx
index b22e7d2..b6fa248 100644
--- a/apps/docs/recipes/progress/preact.tsx
+++ b/apps/docs/recipes/progress/preact.tsx
@@ -49,11 +49,9 @@ function Trigger() {
             progressLayer.stack.update(layer, { percent });
             if (percent >= 100) {
               clearInterval(interval);
-              void progressLayer.stack
-                .dismiss(layer, undefined as void)
-                .then(() => {
-                  setStatus("complete");
-                });
+              void progressLayer.stack.dismiss(layer).then(() => {
+                setStatus("complete");
+              });
             }
           }, 150);
         }}
diff --git a/apps/docs/recipes/progress/react.tsx b/apps/docs/recipes/progress/react.tsx
index e75170d..9c27d40 100644
--- a/apps/docs/recipes/progress/react.tsx
+++ b/apps/docs/recipes/progress/react.tsx
@@ -49,11 +49,9 @@ function Trigger() {
             progressLayer.stack.update(layer, { percent });
             if (percent >= 100) {
               clearInterval(interval);
-              void progressLayer.stack
-                .dismiss(layer, undefined as void)
-                .then(() => {
-                  setStatus("complete");
-                });
+              void progressLayer.stack.dismiss(layer).then(() => {
+                setStatus("complete");
+              });
             }
           }, 150);
         }}
diff --git a/apps/docs/recipes/progress/solid.tsx b/apps/docs/recipes/progress/solid.tsx
index a2e8248..b59c1be 100644
--- a/apps/docs/recipes/progress/solid.tsx
+++ b/apps/docs/recipes/progress/solid.tsx
@@ -54,11 +54,9 @@ function Trigger() {
             progressLayer.stack.update(layer, { percent });
             if (percent >= 100) {
               clearInterval(interval);
-              void progressLayer.stack
-                .dismiss(layer, undefined as void)
-                .then(() => {
-                  setStatus("complete");
-                });
+              void progressLayer.stack.dismiss(layer).then(() => {
+                setStatus("complete");
+              });
             }
           }, 150);
         }}
diff --git a/apps/docs/recipes/progress/svelte-runes.svelte b/apps/docs/recipes/progress/svelte-runes.svelte
index ef7708f..3e04718 100644
--- a/apps/docs/recipes/progress/svelte-runes.svelte
+++ b/apps/docs/recipes/progress/svelte-runes.svelte
@@ -40,7 +40,7 @@
       c.stack.update(layer, { percent });
       if (percent >= 100) {
         clearInterval(interval);
-        void c.stack.dismiss(layer, undefined as void).then(() => {
+        void c.stack.dismiss(layer).then(() => {
           status = "complete";
         });
       }
diff --git a/apps/docs/recipes/progress/svelte-store.svelte b/apps/docs/recipes/progress/svelte-store.svelte
index d2dde10..101951c 100644
--- a/apps/docs/recipes/progress/svelte-store.svelte
+++ b/apps/docs/recipes/progress/svelte-store.svelte
@@ -43,7 +43,7 @@
       c.stack.update(layer, { percent });
       if (percent >= 100) {
         clearInterval(interval);
-        void c.stack.dismiss(layer, undefined as void).then(() => {
+        void c.stack.dismiss(layer).then(() => {
           status = "complete";
         });
       }
diff --git a/apps/docs/recipes/progress/vue-host.vue b/apps/docs/recipes/progress/vue-host.vue
index 65b8235..31a058b 100644
--- a/apps/docs/recipes/progress/vue-host.vue
+++ b/apps/docs/recipes/progress/vue-host.vue
@@ -36,7 +36,7 @@ function startUpload() {
     c.stack.update(layer, { percent });
     if (percent >= 100) {
       clearInterval(interval);
-      void c.stack.dismiss(layer, undefined as void).then(() => {
+      void c.stack.dismiss(layer).then(() => {
         status.value = "complete";
       });
     }
diff --git a/docs/architecture.md b/docs/architecture.md
index 4bc0f1f..01f237b 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -121,15 +121,15 @@ stack.addBlocker(fn: (layer: LayerState) => boolean | Promise<boolean>): () => v
 **Async + reject** — predicates may be async; `dismiss` awaits them. A veto **rejects** the attempt (layer stays open; caller re-issues after confirming) rather than deferring the caller's `Promise<R>`. Confirm UI is the consumer's own layer — core never opens UI.
 
 ```ts
-call.end(response, opts?: { force?: boolean }): Promise<boolean>;   // was void
-call.dismiss(response, opts?: { force?: boolean }): Promise<boolean>;
+call.end(...args: EndArgs<R>): Promise<boolean>;
+call.dismiss(...args: EndArgs<R>): Promise<boolean>;
 ```
 
-Return value = "did it dismiss?". `{ force: true }` bypasses blockers. Repeat `end`/`dismiss` while `dismissing` dedupes to the in-flight promise; `force` wins immediately. Predicate throw/reject = veto (fail-closed; dev warning).
+Response optional when `undefined extends R` (same gate as `PayloadArg`). Return value = "did it dismiss?". `{ force: true }` bypasses blockers. Repeat `end`/`dismiss` while `dismissing` dedupes to the in-flight promise; `force` wins immediately. Predicate throw/reject = veto (fail-closed; dev warning).
 
 **Paths** — honor blockers: `end`/`dismiss` (user intent). Skip: `cancelQueued` (serial, never mounted), `cancelAll` (system teardown). **Layer-group cascade** (`onLayerDismiss` → `#drainChildStacks` → `cancelAll`) rejects child `open()` with `LayerCancelledError` — guard the parent instead.
 
-**`dismissAll` modes** — `stack.dismissAll(response, opts?: { mode? })` is async:
+**`dismissAll` modes** — `stack.dismissAll(...args: DismissAllArgs<R>)` is async:
 
 | mode                      | behavior                                          |
 | ------------------------- | ------------------------------------------------- |
diff --git a/packages/angular/skills/angular-layers/SKILL.md b/packages/angular/skills/angular-layers/SKILL.md
index 46c9ba2..ba0d80f 100644
--- a/packages/angular/skills/angular-layers/SKILL.md
+++ b/packages/angular/skills/angular-layers/SKILL.md
@@ -170,7 +170,7 @@ When `P` is `void`, `unknown`, `undefined`, or a union containing `undefined`, o
 
 ## The `call` context
 
-Each mounted layer gets a `LayerCallContext` from `createCallContext(stack, layer, state)` (or via `useStackHandles().getCall(state)` / `renderStack`'s `call` input). It provides `end`, `dismiss`, `update`, `setRunning`, `settle`, `ended`, `index`, `stackSize`, `root`, `stackId`, `layerId`, and `addBlocker`; the `LayerState` snapshot provides `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, and `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>`; `false` when a blocker vetoes).
+Each mounted layer gets a `LayerCallContext` from `createCallContext(stack, layer, state)` (or via `useStackHandles().getCall(state)` / `renderStack`'s `call` input). It provides `end`, `dismiss`, `update`, `setRunning`, `settle`, `ended`, `index`, `stackSize`, `root`, `stackId`, `layerId`, and `addBlocker`; the `LayerState` snapshot provides `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, and `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>`; `false` when a blocker vetoes). When `undefined extends R` (e.g. void toasts), omit the arg — `call.end()` / `call.dismiss()`.
 
 **Key vs id:** `key` is the logical identity used by `find`, `upsert`, and `gcTime`; each mount gets a unique instance `id`. Track `s.id` in `@for` because parallel stacks may contain multiple layers with the same key.
 
diff --git a/packages/core/skills/layers/SKILL.md b/packages/core/skills/layers/SKILL.md
index 12ed34e..1e3971f 100644
--- a/packages/core/skills/layers/SKILL.md
+++ b/packages/core/skills/layers/SKILL.md
@@ -149,7 +149,7 @@ const ok = await client.open({
 
 ## The `call` context
 
-`createCallContext` gives an active layer `end`, `dismiss`, `addBlocker`, `update`, `setRunning`, and `settle`, plus `ended`, `index`, `stackSize`, `root`, `stackId`, and `layerId`. `await call.end(response)` and `await call.dismiss(response)` request dismissal; when allowed, they resolve the caller and begin exit. Both return `Promise<boolean>`, with `false` meaning a blocker vetoed dismissal. `update` patches payload, `setRunning` controls `actionStatus`, and `settle` completes the current enter or exit transition.
+`createCallContext` gives an active layer `end`, `dismiss`, `addBlocker`, `update`, `setRunning`, and `settle`, plus `ended`, `index`, `stackSize`, `root`, `stackId`, and `layerId`. `await call.end(response)` and `await call.dismiss(response)` request dismissal; when allowed, they resolve the caller and begin exit. Both return `Promise<boolean>`, with `false` meaning a blocker vetoed dismissal. When `undefined extends R` (e.g. `R = void`), omit the response — `call.end()` / `call.dismiss()` — same gate as `PayloadArg` / `.open()` (`EndArgs`). `update` patches payload, `setRunning` controls `actionStatus`, and `settle` completes the current enter or exit transition.
 
 `key` is logical identity for `find`, `upsert`, and `gcTime`; every mount gets a unique instance `id` shaped as `${hashKey(key)}#<n>`. Keys must be JSON-safe (`string` | `boolean` | `null` | finite `number` | plain objects/arrays of those); `hashKey` / `keySignature` assert that domain and throw `LayerKeyError` otherwise. Parallel stacks may contain multiple same-key instances.
 
@@ -171,7 +171,7 @@ call.addBlocker(async () =>
 );
 ```
 
-`dismissing` is `true` while blockers run, and `{ force: true }` bypasses them. `stack.dismissAll(response, { mode })` supports `skipBlocked`, `stopAtBlocked`, and `force`; the default is `skipBlocked`, configurable per stack with `dismissAllMode` in `defaultStackOptions`. System teardown uses `cancelAll` (parent-dismiss child drain, group dispose, host disconnect) and rejects `open()` with `LayerCancelledError` — narrow with `isLayerCancelledError`. Do not conflate that with user dismiss / `dismissAll(response)`, which still resolve with `R`.
+`dismissing` is `true` while blockers run, and `{ force: true }` bypasses them. `stack.dismissAll(...args)` supports `skipBlocked`, `stopAtBlocked`, and `force`; the default is `skipBlocked`, configurable per stack with `dismissAllMode` in `defaultStackOptions`. Omit the response when `undefined extends R` (`EndArgs` gate). System teardown uses `cancelAll` (parent-dismiss child drain, group dispose, host disconnect) and rejects `open()` with `LayerCancelledError` — narrow with `isLayerCancelledError`. Do not conflate that with user dismiss / `dismissAll`, which complete `open()` with `R` (resolve, not reject).
 
 ## Payload validation
 
@@ -220,7 +220,7 @@ const completion = client.open({
 const layer = toast.find(["toast", "export"])!;
 toast.update(layer, { msg: "Done" });
 
-await toast.dismiss(layer, undefined);
+await toast.dismiss(layer);
 await completion;
 ```
 
@@ -282,7 +282,7 @@ The complete public API surface:
 | Layer model types                | `LayerKey`, `LayerPhase`, `LayerTransition`, `LayerActionStatus`, `LayerState`, `LayerOptions`, `OpenLayerOptions`            |
 | Stack and client types           | `StackOptions`, `StackDefaults`, `LayerClientOptions`                                                                         |
 | Dismissal types                  | `BlockerFn`, `StackBlockerFn`, `DismissOptions`, `DismissAllOptions`, `DismissAllMode`                                        |
-| Utility and configuration types  | `Resolve`, `Reject`, `PayloadArg`, `OmitKeyof`, `Register`, `DefaultLayerError`                                               |
+| Utility and configuration types  | `Resolve`, `Reject`, `PayloadArg`, `EndArgs`, `OmitKeyof`, `Register`, `DefaultLayerError`                                    |
 
 ## Agnostic contract
 
diff --git a/packages/core/src/callContext.test.ts b/packages/core/src/callContext.test.ts
index b2b5807..6b3a87e 100644
--- a/packages/core/src/callContext.test.ts
+++ b/packages/core/src/callContext.test.ts
@@ -77,4 +77,15 @@ describe("createCallContext", () => {
     expect(await dismissResult).toBe(true);
     expect(stack.getSnapshot()).toHaveLength(0);
   });
+
+  it("end() with no args resolves void-R layers", async () => {
+    const stack = new LayerStack<{ n: number }, void>("s");
+    const layer = stack.open({ key: ["a"], payload: { n: 1 } });
+    const state = stack.getSnapshot()[0]!;
+    const call = createCallContext(stack, layer, state);
+
+    await expect(call.end()).resolves.toBe(true);
+    await expect(layer.promise.promise).resolves.toBe(undefined);
+    expect(stack.getSnapshot()).toHaveLength(0);
+  });
 });
diff --git a/packages/core/src/callContext.ts b/packages/core/src/callContext.ts
index b4deb97..8522e6a 100644
--- a/packages/core/src/callContext.ts
+++ b/packages/core/src/callContext.ts
@@ -2,7 +2,7 @@ import type { Layer } from "./layer";
 import { LayerStack } from "./layerStack";
 import type {
   DefaultLayerError,
-  DismissOptions,
+  EndArgs,
   LayerCallContext,
   LayerState,
 } from "./types";
@@ -18,10 +18,14 @@ export function createCallContext<P, R, RootProps = unknown>(
   rootProps?: RootProps,
 ): LayerCallContext<P, R, RootProps> {
   return {
-    end: (response: R, opts?: DismissOptions) =>
-      stack.dismiss(layer, response, opts),
-    dismiss: (response: R, opts?: DismissOptions) =>
-      stack.dismiss(layer, response, opts),
+    end: (...args: EndArgs<R>) => {
+      const [response, opts] = args;
+      return stack.dismiss(layer, response as R, opts);
+    },
+    dismiss: (...args: EndArgs<R>) => {
+      const [response, opts] = args;
+      return stack.dismiss(layer, response as R, opts);
+    },
     addBlocker: (fn) => layer.addBlocker(fn),
     update: (patch: Partial<P>) => stack.update(layer, patch),
     setRunning: (running: boolean) => stack.setRunning(layer, running),
diff --git a/packages/core/src/createLayer.test.ts b/packages/core/src/createLayer.test.ts
index 38c7158..c72940f 100644
--- a/packages/core/src/createLayer.test.ts
+++ b/packages/core/src/createLayer.test.ts
@@ -115,9 +115,41 @@ describe("createLayer — control surface", () => {
     await handle.dismiss(true);
     expect(await pending).toBe(true);
   });
+
+  it("dismiss() omits response for void R", async () => {
+    const client = new LayerClient();
+    const handle = createLayer(
+      layerOptions<{ n: number }, void>({ key: ["void-r"] }),
+      client,
+    );
+    const pending = handle.open({ n: 1 });
+    await expect(handle.dismiss()).resolves.toBe(true);
+    await expect(pending).resolves.toBe(undefined);
+  });
 });
 
 describe("createLayer — cancelQueued", () => {
+  it("cancelQueued() omits response for void R", async () => {
+    const client = new LayerClient({
+      defaultStackOptions: {
+        default: { scope: { strategy: "serial" } },
+      },
+    });
+    const handleA = createLayer(
+      layerOptions<{ n: number }, void>({ key: ["a"] }),
+      client,
+    );
+    const handleB = createLayer(
+      layerOptions<{ n: number }, void>({ key: ["b"] }),
+      client,
+    );
+    void handleA.open({ n: 1 });
+    const pending = handleB.open({ n: 2 });
+    expect(handleB.cancelQueued()).toBe(true);
+    await expect(pending).resolves.toBe(undefined);
+    await handleA.dismiss();
+  });
+
   it("cancelQueued resolves a queued layer without mounting it", async () => {
     const client = new LayerClient({
       defaultStackOptions: {
diff --git a/packages/core/src/createLayer.ts b/packages/core/src/createLayer.ts
index e893f19..8239ab8 100644
--- a/packages/core/src/createLayer.ts
+++ b/packages/core/src/createLayer.ts
@@ -3,8 +3,9 @@ import type { Layer } from "./layer";
 import type { LayerClient } from "./layerClient";
 import type { LayerStack } from "./layerStack";
 import type {
+  CancelQueuedArgs,
   DefaultLayerError,
-  DismissOptions,
+  HandleDismissArgs,
   LayerKey,
   LayerOptions,
   PayloadArg,
@@ -39,16 +40,20 @@ type NoValidateOptions<Opts> = Opts extends { validate: Validator<unknown> }
 export interface LayerHandle<P, R, E, D, RP> {
   open: (payload: PayloadArg<P>["payload"]) => Promise<R>;
   upsert: (payload: PayloadArg<P>["payload"]) => Promise<R>;
-  dismiss: (
-    response?: R,
-    opts?: DismissOptions & { id?: string },
-  ) => Promise<boolean>;
+  /**
+   * Dismiss the bound instance (or `{ id }`).
+   * Response optional iff `undefined extends R` ({@link HandleDismissArgs} /
+   * {@link EndArgs} gate).
+   */
+  dismiss: (...args: HandleDismissArgs<R>) => Promise<boolean>;
   update: (patch: Partial<P>, opts?: { id?: string }) => void;
   /**
    * Resolves and removes a serially queued layer without mounting (skips blockers).
    * No `id` → FIFO head for this key; `{ id }` → exact queued match.
+   * Response may be omitted when `undefined extends R` ({@link CancelQueuedArgs} /
+   * {@link EndArgs} gate).
    */
-  cancelQueued: (response?: R, opts?: { id?: string }) => boolean;
+  cancelQueued: (...args: CancelQueuedArgs<R>) => boolean;
   readonly client: LayerClient;
   readonly stack: LayerStack<P, R, E, D>;
   readonly options: LayerOptions<P, R, E, D, RP> & {
@@ -156,7 +161,8 @@ export function createLayer<
       mine = stack.open({ ...toOpenOpts(payload as P), upsert: true });
       return mine.promise.promise as Promise<R>;
     },
-    dismiss: (response, o) => {
+    dismiss: (...args) => {
+      const [response, o] = args;
       const l = target(o?.id);
       return l
         ? stack.dismiss(l, response as R, { force: o?.force })
@@ -166,8 +172,10 @@ export function createLayer<
       const l = target(o?.id);
       if (l) stack.update(l, patch);
     },
-    cancelQueued: (response, o) =>
-      stack.cancelQueued(opts.key, response ?? (undefined as R), o),
+    cancelQueued: (...args) => {
+      const [response, o] = args;
+      return stack.cancelQueued(opts.key, response as R, o);
+    },
     client,
     stack,
     options: opts,
diff --git a/packages/core/src/index.test-d.ts b/packages/core/src/index.test-d.ts
index 02e1d2d..59f180f 100644
--- a/packages/core/src/index.test-d.ts
+++ b/packages/core/src/index.test-d.ts
@@ -7,9 +7,13 @@ import { LayerClient, createLayer, layerKey, layerOptions } from "./index";
 import type {
   DataTag,
   DefaultLayerError,
+  DismissAllArgs,
+  EndArgs,
   InferDataTagError,
   InferDataTagResponse,
+  LayerCallContext,
   LayerKey,
+  LayerStack,
   OmitKeyof,
   StandardSchemaV1,
 } from "./index";
@@ -267,3 +271,115 @@ export type _CreateLayerCurrentPayload = Expect<
     { title: string }
   >
 >;
+
+// EndArgs — response optional iff `undefined extends R` (twin of PayloadArg).
+declare const voidCall: LayerCallContext<unknown, void>;
+function endVoidOmitted() {
+  return voidCall.end();
+}
+void endVoidOmitted;
+function endVoidUndefined() {
+  return voidCall.end(undefined);
+}
+void endVoidUndefined;
+function endVoidForce() {
+  return voidCall.end(undefined, { force: true });
+}
+void endVoidForce;
+function endVoidOptsOnly() {
+  // @ts-expect-error opts-only — pass response (or undefined) before force
+  return voidCall.end({ force: true });
+}
+void endVoidOptsOnly;
+function endVoidTrue() {
+  // @ts-expect-error void response is not boolean
+  return voidCall.end(true);
+}
+void endVoidTrue;
+
+declare const boolCall: LayerCallContext<unknown, boolean>;
+function endBoolOmitted() {
+  // @ts-expect-error boolean response is required
+  return boolCall.end();
+}
+void endBoolOmitted;
+function endBoolTrue() {
+  return boolCall.end(true);
+}
+void endBoolTrue;
+
+declare const optCall: LayerCallContext<unknown, boolean | undefined>;
+function endOptOmitted() {
+  return optCall.end();
+}
+void endOptOmitted;
+function endOptTrue() {
+  return optCall.end(true);
+}
+void endOptTrue;
+
+export type _EndArgsVoidOptional = Expect<
+  Equal<EndArgs<void>, [response?: void, opts?: { force?: boolean }]>
+>;
+export type _EndArgsBoolRequired = Expect<
+  Equal<EndArgs<boolean>, [response: boolean, opts?: { force?: boolean }]>
+>;
+
+// Handle dismiss — same gate (closes always-optional hole).
+const voidDismissHandle = createLayer(
+  layerOptions<{ n: number }, void>({ key: ["void-dismiss"] }),
+  confirmClient,
+);
+function dismissVoidHandleOmitted() {
+  return voidDismissHandle.dismiss();
+}
+void dismissVoidHandleOmitted;
+
+const boolDismissHandle = createLayer(
+  layerOptions<{ n: number }, boolean>({ key: ["bool-dismiss"] }),
+  confirmClient,
+);
+function dismissBoolHandleOmitted() {
+  // @ts-expect-error boolean response is required on the handle
+  return boolDismissHandle.dismiss();
+}
+void dismissBoolHandleOmitted;
+function dismissBoolHandleTrue() {
+  return boolDismissHandle.dismiss(true);
+}
+void dismissBoolHandleTrue;
+
+function cancelQueuedVoidHandleOmitted() {
+  return voidDismissHandle.cancelQueued();
+}
+void cancelQueuedVoidHandleOmitted;
+function cancelQueuedBoolHandleOmitted() {
+  // @ts-expect-error boolean response is required on cancelQueued
+  return boolDismissHandle.cancelQueued();
+}
+void cancelQueuedBoolHandleOmitted;
+function cancelQueuedBoolHandleFalse() {
+  return boolDismissHandle.cancelQueued(false);
+}
+void cancelQueuedBoolHandleFalse;
+
+declare const voidStack: LayerStack<{ n: number }, void>;
+function dismissAllVoidOmitted() {
+  return voidStack.dismissAll();
+}
+void dismissAllVoidOmitted;
+declare const boolStack: LayerStack<{ n: number }, boolean>;
+function dismissAllBoolOmitted() {
+  // @ts-expect-error boolean response is required on dismissAll
+  return boolStack.dismissAll();
+}
+void dismissAllBoolOmitted;
+export type _DismissAllArgsVoidOptional = Expect<
+  Equal<
+    DismissAllArgs<void>,
+    [
+      response?: void,
+      opts?: { mode?: "skipBlocked" | "stopAtBlocked" | "force" },
+    ]
+  >
+>;
diff --git a/packages/core/src/layerStack.test.ts b/packages/core/src/layerStack.test.ts
index 6c384f2..5f7636d 100644
--- a/packages/core/src/layerStack.test.ts
+++ b/packages/core/src/layerStack.test.ts
@@ -432,6 +432,14 @@ describe("LayerStack — scope serial", () => {
     expect(stack.getSnapshot()).toHaveLength(0);
   });
 
+  it("dismissAll() omits response for void R", async () => {
+    const stack = new LayerStack<{ n: number }, void>("s");
+    const layer = stack.open({ key: ["a"], payload: { n: 1 } });
+    await stack.dismissAll();
+    await expect(layer.promise.promise).resolves.toBe(undefined);
+    expect(stack.getSnapshot()).toHaveLength(0);
+  });
+
   it("onLoadError block (default): error occupies lane; queued waits; no leapfrog", async () => {
     let rejectLoad!: (error: Error) => void;
     const stack = new LayerStack<{ n: number }, boolean, Error>("s", {
diff --git a/packages/core/src/layerStack.ts b/packages/core/src/layerStack.ts
index f0ee490..6d521f4 100644
--- a/packages/core/src/layerStack.ts
+++ b/packages/core/src/layerStack.ts
@@ -5,9 +5,10 @@ import { createLayerGcCache } from "./layerGcCache";
 import { notifyManager } from "./notifyManager";
 import { Subscribable } from "./subscribable";
 import type {
+  CancelQueuedArgs,
   DefaultLayerError,
-  DismissAllOptions,
-  DismissOptions,
+  DismissAllArgs,
+  EndArgs,
   LayerKey,
   LayerNotifyView,
   LayerState,
@@ -257,20 +258,19 @@ export class LayerStack<
   /**
    * Resolves the caller and aborts in-flight loading.
    * Exiting layers remain mounted until their transition settles.
+   * Response may be omitted when `undefined extends R` ({@link EndArgs}).
    */
-  dismiss(
-    layer: Layer<P, R, E, D>,
-    response: R,
-    opts?: DismissOptions,
-  ): Promise<boolean> {
+  dismiss(layer: Layer<P, R, E, D>, ...args: EndArgs<R>): Promise<boolean> {
+    const [response, opts] = args;
+    const r = response as R;
     if (opts?.force) {
-      this.#commitDismiss(layer, response);
+      this.#commitDismiss(layer, r);
       return Promise.resolve(true);
     }
     if (layer.dismissPending) {
       return layer.dismissPending;
     }
-    layer.dismissPending = this.#guardedDismiss(layer, response).finally(() => {
+    layer.dismissPending = this.#guardedDismiss(layer, r).finally(() => {
       layer.dismissPending = undefined;
     });
     return layer.dismissPending;
@@ -380,11 +380,14 @@ export class LayerStack<
 
   /**
    * Bulk-dismisses active and queued layers, completing every `open()` with
-   * `response` (including `undefined` when `R` is `void`). Honors
-   * {@link DismissAllMode}; does not reject — use {@link cancelAll} for
+   * `response` (including omitted/`undefined` when `undefined extends R` —
+   * {@link DismissAllArgs} / {@link EndArgs} gate).
+   * Honors {@link DismissAllMode}; does not reject — use {@link cancelAll} for
    * teardown without a completion value.
    */
-  async dismissAll(response: R, opts?: DismissAllOptions): Promise<void> {
+  async dismissAll(...args: DismissAllArgs<R>): Promise<void> {
+    const [response, opts] = args;
+    const r = response as R;
     const mode = opts?.mode ?? this.options.dismissAllMode ?? "skipBlocked";
     // Final labeled snapshot: active-only stacks only emit per-layer `"dismiss"`.
     const shouldEmit = this.#scopeQueue.length > 0 || this.#layers.length > 0;
@@ -395,12 +398,12 @@ export class LayerStack<
         // without ever mounting.
         for (const entry of this.#scopeQueue) {
           entry.layer.abort();
-          entry.layer.resolve(response);
+          entry.layer.resolve(r);
           entry.layer.setPartial({
             phase: "dismissed",
             transition: "settled",
             ended: true,
-            response,
+            response: r,
           });
         }
         this.#scopeQueue = [];
@@ -408,10 +411,10 @@ export class LayerStack<
       });
       for (const l of this.#layers) {
         if (mode === "force") {
-          await this.dismiss(l, response, { force: true });
+          await this.dismiss(l, r, { force: true });
           continue;
         }
-        const ok = await this.dismiss(l, response);
+        const ok = await this.dismiss(l, r);
         if (!ok && mode === "stopAtBlocked") {
           return;
         }
@@ -484,8 +487,12 @@ export class LayerStack<
   /**
    * Resolves and removes a serially queued layer without mounting it (skips blockers).
    * No `id` → FIFO head for the key; `{ id }` → exact queued match.
+   * Response may be omitted when `undefined extends R` ({@link CancelQueuedArgs} /
+   * {@link EndArgs} gate).
    */
-  cancelQueued(key: LayerKey, response: R, opts?: { id?: string }): boolean {
+  cancelQueued(key: LayerKey, ...args: CancelQueuedArgs<R>): boolean {
+    const [response, opts] = args;
+    const r = response as R;
     return notifyManager.batch(() => {
       return this.#dispatch("cancelQueued", () => {
         const sig = keySignature(key);
@@ -499,12 +506,12 @@ export class LayerStack<
         }
         const entry = this.#scopeQueue[idx]!;
         entry.layer.abort();
-        entry.layer.resolve(response);
+        entry.layer.resolve(r);
         entry.layer.setPartial({
           phase: "dismissed",
           transition: "settled",
           ended: true,
-          response,
+          response: r,
         });
         this.#scopeQueue.splice(idx, 1);
         this.#flush();
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index 473a05c..543a1e4 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -73,8 +73,10 @@ export interface LayerState<
 
 /** Imperative controls available to a rendered layer. */
 export interface LayerCallContext<P, R, RootProps = unknown> {
-  end: (response: R, opts?: DismissOptions) => Promise<boolean>;
-  dismiss: (response: R, opts?: DismissOptions) => Promise<boolean>;
+  /** Resolve and dismiss — response optional iff `undefined extends R` ({@link EndArgs}). */
+  end: (...args: EndArgs<R>) => Promise<boolean>;
+  /** Alias of {@link LayerCallContext.end}. */
+  dismiss: (...args: EndArgs<R>) => Promise<boolean>;
   addBlocker: (fn: BlockerFn) => () => void;
   update: (patch: Partial<P>) => void;
   setRunning: (running: boolean) => void;
@@ -149,6 +151,31 @@ export type PayloadArg<P> = undefined extends P
   ? { payload?: P }
   : { payload: P };
 
+/** Rest-tuple factory used by {@link EndArgs} and stack/handle variants. */
+export type ResponseArgTuple<R, Opts> = undefined extends R
+  ? [response?: R, opts?: Opts]
+  : [response: R, opts?: Opts];
+
+/**
+ * Rest-args for `call.end` / `call.dismiss` / `LayerStack.dismiss`.
+ * Response is optional only when `R` admits `undefined` — twin of {@link PayloadArg}.
+ * When response is optional, pass opts as the second arg (`end(undefined, { force: true })`);
+ * a lone object is treated as the response (not as opts).
+ */
+export type EndArgs<R> = ResponseArgTuple<R, DismissOptions>;
+
+/** `LayerStack.dismissAll` rest-args (same gate as {@link EndArgs}). */
+export type DismissAllArgs<R> = ResponseArgTuple<R, DismissAllOptions>;
+
+/** `cancelQueued` rest-args (same gate as {@link EndArgs}). */
+export type CancelQueuedArgs<R> = ResponseArgTuple<R, { id?: string }>;
+
+/** `LayerHandle.dismiss` rest-args (same gate as {@link EndArgs}; opts may include `id`). */
+export type HandleDismissArgs<R> = ResponseArgTuple<
+  R,
+  DismissOptions & { id?: string }
+>;
+
 export type OpenLayerOptions<
   P = unknown,
   R = void,
diff --git a/packages/preact/skills/preact-layers/SKILL.md b/packages/preact/skills/preact-layers/SKILL.md
index 06307d8..afd2777 100644
--- a/packages/preact/skills/preact-layers/SKILL.md
+++ b/packages/preact/skills/preact-layers/SKILL.md
@@ -125,7 +125,7 @@ Low-level bag-form: `useLayerClient()` + `client.open({ ...confirm, payload })`.
 
 ## The `call` context
 
-Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if a blocker vetoes). `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
+Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if a blocker vetoes). When `undefined extends R` (e.g. void toasts), omit the arg — `call.end()` / `call.dismiss()`. `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
 
 **Key vs id:** `key` is the logical identity (`find`/`upsert`/`gcTime`); each mount gets a unique instance `id`. Use `s.id` for list keys; `parallel` stacks may hold multiple same-key layers.
 
diff --git a/packages/react/skills/react-layers/SKILL.md b/packages/react/skills/react-layers/SKILL.md
index d3382f6..6f7eed5 100644
--- a/packages/react/skills/react-layers/SKILL.md
+++ b/packages/react/skills/react-layers/SKILL.md
@@ -116,7 +116,7 @@ Low-level: `client.open({ ...confirm, payload })` or core `createLayer(confirm,
 
 ## The `call` context
 
-Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if a blocker vetoes). `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
+Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if a blocker vetoes). When `undefined extends R` (e.g. void toasts), omit the arg — `call.end()` / `call.dismiss()`. `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
 
 **Key vs id:** `key` is the logical identity (`find`/`upsert`/`gcTime`); each mount gets a unique instance `id`. Use `s.id` for React list keys; `parallel` stacks may hold multiple same-key layers.
 
diff --git a/packages/solid/skills/solid-layers/SKILL.md b/packages/solid/skills/solid-layers/SKILL.md
index 9044563..1733fc6 100644
--- a/packages/solid/skills/solid-layers/SKILL.md
+++ b/packages/solid/skills/solid-layers/SKILL.md
@@ -121,7 +121,7 @@ Low-level bag-form: `useLayerClient()` + `client.open({ ...confirm, payload })`.
 
 ## The `call` context
 
-Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, and `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if a blocker vetoes). `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
+Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, and `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if a blocker vetoes). When `undefined extends R` (e.g. void toasts), omit the arg — `call.end()` / `call.dismiss()`. `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
 
 **Key vs id:** `key` is the logical identity (`find`/`upsert`/`gcTime`); each mount gets a unique instance `id`. `StackOutlet` keys by `id` so state changes update props in place; `parallel` stacks may hold multiple same-key layers.
 
diff --git a/packages/svelte/skills/svelte-layers/SKILL.md b/packages/svelte/skills/svelte-layers/SKILL.md
index 6180a04..5a62db0 100644
--- a/packages/svelte/skills/svelte-layers/SKILL.md
+++ b/packages/svelte/skills/svelte-layers/SKILL.md
@@ -230,7 +230,7 @@ Each layer component receives:
 - `call`: `end`, `dismiss`, `update`, `setRunning`, `settle`, `ended`, `index`, `stackSize`, `root`, `stackId`, `layerId`, and `addBlocker`
 - state props: `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, and `dismissing`
 
-`await call.end(response)` resolves the caller's `await` and dismisses the layer. It returns `Promise<boolean>`; `false` means a blocker vetoed dismissal.
+`await call.end(response)` resolves the caller's `await` and dismisses the layer. It returns `Promise<boolean>`; `false` means a blocker vetoed dismissal. When `undefined extends R` (e.g. void toasts), omit the arg — `call.end()` / `call.dismiss()`.
 
 `key` is logical identity for operations such as `find`, `upsert`, and `gcTime`; every mount gets a unique `id`. Key `{#each}` blocks with `s.id`, because parallel stacks may contain multiple same-key layers.
 
diff --git a/packages/vue/skills/vue-layers/SKILL.md b/packages/vue/skills/vue-layers/SKILL.md
index 42a9672..3662da5 100644
--- a/packages/vue/skills/vue-layers/SKILL.md
+++ b/packages/vue/skills/vue-layers/SKILL.md
@@ -164,7 +164,7 @@ function showNotice() {
 
 ## The `call` context
 
-Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if vetoed). `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
+Each layer component receives `call` (`end`/`dismiss`/`update`/`setRunning`/`settle`/`ended`/`index`/`stackSize`/`root`/`stackId`/`layerId`/`addBlocker`), `payload`, `data`, `error`, `phase`, `transition`, `actionStatus`, `dismissing`. Use `await call.end(response)` to resolve the caller's `await` and dismiss the layer (`Promise<boolean>` — `false` if vetoed). When `undefined extends R` (e.g. void toasts), omit the arg — `call.end()` / `call.dismiss()`. `setRunning(true|false)` flips `actionStatus` manually; `useMutationFlow` (below) wraps `setRunning` + `end` for the common save-then-close case.
 
 **Key vs id:** `key` is the logical identity (`find`/`upsert`/`gcTime`); each mount gets a unique instance `id`. Use `s.id` for `v-for` keys; `parallel` stacks may hold multiple same-key layers.