refactor: remove fallback option from dispatchOrgScopedList

The fallback added complexity for minimal benefit — a shared local
handler assigned to each mode key is clearer and just as concise.

Author: BYK

AGENTS.md

@@ -329,7 +329,6 @@ Two abstraction levels exist for list commands:
 
 Key rules when writing overrides:
 - Each mode handler receives a `HandlerContext<T>` with the narrowed `parsed` plus shared I/O (`stdout`, `cwd`, `flags`). Access parsed fields via `ctx.parsed.org`, `ctx.parsed.projectSlug`, etc. — no manual `Extract<>` casts needed.
-- When multiple modes share one handler, use the `fallback` option instead of repeating the handler for each key: `fallback: (ctx) => sharedHandler({ ...ctx, extra })`.
 - Commands with extra fields (e.g., `stderr`, `setContext`) spread the context and add them: `(ctx) => handle({ ...ctx, flags, stderr, setContext })`. Override `ctx.flags` with the command-specific flags type when needed.
 - `resolveCursor()` must be called **inside** the `org-all` override closure, not before `dispatchOrgScopedList`, so that `--cursor` validation errors fire correctly for non-org-all modes.
 - `handleProjectSearch` errors must use `"Project"` as the `ContextError` resource, not `config.entityName`.

src/commands/issue/list.ts

@@ -44,6 +44,7 @@ import {
 import {
   dispatchOrgScopedList,
   type ListCommandMeta,
+  type ModeHandler,
 } from "../../lib/org-list.js";
 import {
   type ResolvedTarget,
@@ -700,15 +701,20 @@ export const listCommand = buildCommand({
 
     const parsed = parseOrgProjectArg(target);
 
+    // biome-ignore lint/suspicious/noExplicitAny: shared handler accepts any mode variant
+    const resolveAndHandle: ModeHandler<any> = (ctx) =>
+      handleResolvedTargets({ ...ctx, flags, stderr, setContext });
+
     await dispatchOrgScopedList({
       config: issueListMeta,
       stdout,
       cwd,
       flags,
       parsed,
-      fallback: (ctx) =>
-        handleResolvedTargets({ ...ctx, flags, stderr, setContext }),
       overrides: {
+        "auto-detect": resolveAndHandle,
+        explicit: resolveAndHandle,
+        "project-search": resolveAndHandle,
         "org-all": (ctx) =>
           handleOrgAllIssues({
             stdout: ctx.stdout,

src/lib/org-list.ts

@@ -719,38 +719,24 @@ export type DispatchOptions<TEntity = unknown, TWithOrg = unknown> = {
   /**
    * Per-mode handler overrides. Each key matches a `ParsedOrgProject["type"]`.
    * Provided handlers replace the corresponding default handler; unspecified
-   * modes fall back to {@link fallback} (if given) then the defaults from
-   * {@link buildDefaultHandlers}.
+   * modes fall back to the defaults from {@link buildDefaultHandlers}.
    */
   overrides?: ModeOverrides;
-  /**
-   * Fallback handler invoked for any mode not covered by `overrides`.
-   *
-   * Useful when most modes share the same handler and only one or two need
-   * custom logic.  Receives the full `HandlerContext<ParsedOrgProject["type"]>`
-   * so it can be reused across modes without casts.
-   *
-   * Resolution order: `overrides[mode]` → `fallback` → default handler.
-   */
-  fallback?: ModeHandler;
 };
 
 /**
  * Validate the cursor flag and dispatch to the correct mode handler.
  *
  * Builds a {@link HandlerContext} from the shared fields (stdout, cwd, flags,
- * parsed) and passes it to the resolved handler.  Resolution order:
- *
- * 1. `overrides[parsed.type]` — caller-supplied per-mode handler
- * 2. `fallback` — catch-all handler for modes not in overrides
- * 3. Default handler from {@link buildDefaultHandlers}
+ * parsed) and passes it to the resolved handler.  Merges default handlers
+ * with caller-provided overrides using `{ ...defaults, ...overrides }`.
  *
  * This is the single entry point for all org-scoped list commands.
  */
 export async function dispatchOrgScopedList<TEntity, TWithOrg>(
   options: DispatchOptions<TEntity, TWithOrg>
 ): Promise<void> {
-  const { config, stdout, cwd, flags, parsed, overrides, fallback } = options;
+  const { config, stdout, cwd, flags, parsed, overrides } = options;
 
   // Cursor pagination is only supported in org-all mode
   if (flags.cursor && parsed.type !== "org-all") {
@@ -763,7 +749,8 @@ export async function dispatchOrgScopedList<TEntity, TWithOrg>(
   }
 
   const defaults = buildDefaultHandlers(config);
-  const handler = overrides?.[parsed.type] ?? fallback ?? defaults[parsed.type];
+  const handlers: ModeHandlerMap = { ...defaults, ...overrides };
+  const handler = handlers[parsed.type];
 
   const ctx: HandlerContext = { parsed, stdout, cwd, flags };