diff --git a/crucible/src/plan/starlark.rs b/crucible/src/plan/starlark.rs
index 92360b00..10ff3bf7 100644
--- a/crucible/src/plan/starlark.rs
+++ b/crucible/src/plan/starlark.rs
@@ -67,6 +67,8 @@ struct CompileContext {
     /// Every task a DSL constructor built, keyed by name. A constructed-but-dropped task
     /// silently never runs, so it is a compile error.
     constructed_tasks: BTreeMap<String, FileSpan>,
+    /// Tasks with `otherwise = True`, expanded in `workflow()`.
+    otherwise: BTreeSet<String>,
     /// `session(...)` declarations by name, with the declaring site.
     sessions: BTreeMap<String, (SessionDecl, FileSpan)>,
     /// Declared sessions bound to at least one task.
@@ -312,6 +314,7 @@ impl CompileState {
                 prompt_files: BTreeSet::new(),
                 total_prompt_bytes: 0,
                 constructed_tasks: BTreeMap::new(),
+                otherwise: BTreeSet::new(),
                 sessions: BTreeMap::new(),
                 bound_sessions: BTreeSet::new(),
                 string_session_refs: BTreeMap::new(),
@@ -529,6 +532,7 @@ fn known_kwargs(function: &str) -> &'static [&'static str] {
             "emits_files",
             "when",
             "answers",
+            "otherwise",
         ],
         "skill" => &[
             "name",
@@ -552,6 +556,7 @@ fn known_kwargs(function: &str) -> &'static [&'static str] {
             "emits_files",
             "when",
             "answers",
+            "otherwise",
         ],
         "command" => &[
             "name",
@@ -570,6 +575,7 @@ fn known_kwargs(function: &str) -> &'static [&'static str] {
             "emits_files",
             "when",
             "answers",
+            "otherwise",
         ],
         "evaluate" => &[
             "name",
@@ -590,6 +596,7 @@ fn known_kwargs(function: &str) -> &'static [&'static str] {
             "emits_files",
             "when",
             "answers",
+            "otherwise",
         ],
         "top_k" => &["name", "k", "direction", "depends_on", "required"],
         "route" => &[
@@ -603,6 +610,7 @@ fn known_kwargs(function: &str) -> &'static [&'static str] {
             "stage",
             "when",
             "answers",
+            "otherwise",
         ],
         "noul" => &["ask", "drop"],
         "choice" => &["ask", "options", "drop"],
@@ -638,7 +646,11 @@ fn constructor(
             }
         };
         let tasks = match take_value(&mut named, "tasks")? {
-            Value::List(tasks) => task_list("workflow", tasks)?,
+            Value::List(tasks) => {
+                let mut tasks = task_list("workflow", tasks)?;
+                expand_otherwise(&mut tasks, state)?;
+                tasks
+            }
             _ => return Err(CompileError::TasksNotList),
         };
         let result = take_optional_task_name(&mut named, "result")?;
@@ -746,14 +758,14 @@ fn constructor(
                 model,
                 effort,
             };
-            dsl_task(&mut named, name, kind, session.map(|decl| decl.name))?
+            dsl_task(&mut named, state, name, kind, session.map(|decl| decl.name))?
         }
         "command" => {
             let name = take_declared_name(&mut named, "name")?;
             let kind = TaskKind::Command {
                 command: take_string(&mut named, "run")?,
             };
-            dsl_task(&mut named, name, kind, None)?
+            dsl_task(&mut named, state, name, kind, None)?
         }
         "evaluate" => {
             let name = take_declared_name(&mut named, "name")?;
@@ -762,7 +774,7 @@ fn constructor(
                 threshold: take_optional_number(&mut named, "threshold")?,
                 direction: take_optional_direction(&mut named, "direction")?,
             };
-            dsl_task(&mut named, name, kind, None)?
+            dsl_task(&mut named, state, name, kind, None)?
         }
         "report" => Task {
             name: take_declared_name(&mut named, "name")?,
@@ -854,7 +866,7 @@ fn constructor(
                 over: None,
                 max_fanout: None,
                 revise: None,
-                when: take_when(&mut named)?,
+                when: take_when(&mut named, state, &name)?,
                 name,
             }
         }
@@ -1080,10 +1092,12 @@ fn engine_task(
 
 fn dsl_task(
     named: &mut BTreeMap<String, Value>,
+    state: &CompileState,
     name: TaskName,
     kind: TaskKind,
     session: Option<String>,
 ) -> Result<Task> {
+    let when = take_when(named, state, &name)?;
     let task = Task {
         name,
         task: kind,
@@ -1098,7 +1112,7 @@ fn dsl_task(
         emits_files: take_emitted_files(named)?,
         over: take_over(named)?,
         max_fanout: take_optional_fanout(named)?,
-        when: take_when(named)?,
+        when,
         revise: take_revise(named)?,
     };
     check_fanout(&task)?;
@@ -1252,19 +1266,40 @@ fn take_questions(named: &mut BTreeMap<String, Value>) -> Result<BTreeMap<Questi
         .collect()
 }
 
-/// `when = gate.area, answers = [...]`. A noul's `answers` defaults to `"yes"`.
-fn take_when(named: &mut BTreeMap<String, Value>) -> Result<Option<When>> {
+/// `when = gate.area` with `answers = [...]` or `otherwise = True`. A noul's `answers` defaults
+/// to `"yes"`.
+fn take_when(
+    named: &mut BTreeMap<String, Value>,
+    state: &CompileState,
+    task: &TaskName,
+) -> Result<Option<When>> {
     let answers = take_labels(named, "answers")?;
+    let otherwise = take_bool_default(named, "otherwise", false)?;
     let asked = match named.remove("when") {
         None | Some(Value::None) => {
-            return match answers {
-                Some(_) => Err(CompileError::AnswersWithoutWhen),
-                None => Ok(None),
+            return match (answers, otherwise) {
+                (Some(_), _) => Err(CompileError::AnswersWithoutWhen),
+                (None, true) => Err(CompileError::OtherwiseWithoutWhen),
+                (None, false) => Ok(None),
             };
         }
         Some(Value::Answer(asked)) => asked,
         Some(_) => return Err(CompileError::WhenNotAnAnswer),
     };
+    if otherwise {
+        if answers.is_some() {
+            return Err(CompileError::OtherwiseWithAnswers);
+        }
+        state.context_mut().otherwise.insert(task.0.clone());
+        return Ok(Some(When {
+            task: asked.task,
+            question: asked.question,
+            is: Vec::new(),
+        }));
+    }
+    if answers.as_ref().is_some_and(Vec::is_empty) {
+        return Err(CompileError::EmptyAnswers);
+    }
     let is = match (answers, &asked.asked.kind) {
         (Some(answers), _) => answers,
         (None, QuestionKind::Noul) => vec![identifier("answers", Label::new(NOUL_YES))?],
@@ -1297,6 +1332,64 @@ fn take_when(named: &mut BTreeMap<String, Value>) -> Result<Option<When>> {
     }))
 }
 
+/// Replace each `otherwise` with the labels no other `when` lists.
+fn expand_otherwise(tasks: &mut [Task], state: &CompileState) -> Result<()> {
+    let context = state.context_mut();
+    if context.otherwise.is_empty() {
+        return Ok(());
+    }
+    let pending = |task: &Task| context.otherwise.contains(&task.name.0);
+    let mut listed: BTreeMap<(TaskName, QuestionId), BTreeSet<Label>> = BTreeMap::new();
+    for task in tasks.iter().filter(|task| !pending(task)) {
+        if let Some(when) = &task.when {
+            listed
+                .entry((when.task.clone(), when.question.clone()))
+                .or_default()
+                .extend(when.is.iter().cloned());
+        }
+    }
+    let mut expanded: Vec<(usize, Vec<Label>)> = Vec::new();
+    for (index, task) in tasks.iter().enumerate().filter(|(_, task)| pending(task)) {
+        let Some(when) = &task.when else { continue };
+        let asked = tasks.iter().find_map(|route| match &route.task {
+            TaskKind::Route { questions, .. } if route.name == when.task => {
+                questions.get(&when.question)
+            }
+            _ => None,
+        });
+        let Some(asked) = asked else { continue };
+        let listed_here = listed.get(&(when.task.clone(), when.question.clone()));
+        let rest: Vec<Label> = asked
+            .labels()
+            .into_iter()
+            .chain([Label::uncertain()])
+            .filter(|label| !listed_here.is_some_and(|l| l.contains(label)))
+            .filter(|label| !asked.drop.contains(label))
+            .collect();
+        if rest.is_empty() {
+            let error = CompileError::UnreachableOtherwise {
+                task: task.name.0.clone(),
+                asked: format!("{}.{}", when.task, when.question),
+            };
+            return Err(match context.constructed_tasks.get(&task.name.0) {
+                Some(site) => CompileError::At {
+                    at: site.clone(),
+                    inner: Box::new(error),
+                },
+                None => error,
+            });
+        }
+        expanded.push((index, rest));
+    }
+    drop(context);
+    for (index, rest) in expanded {
+        if let Some(when) = &mut tasks[index].when {
+            when.is = rest;
+        }
+    }
+    Ok(())
+}
+
 fn take_over(named: &mut BTreeMap<String, Value>) -> Result<Option<OutputRef>> {
     match named.remove("over") {
         None | Some(Value::None) => Ok(None),
@@ -3003,6 +3096,171 @@ workflow(type = "playbook", tasks = [classify, gate, fix, punt, page, wrap], res
         assert!(err.contains("did you mean \"route\"?"), "{err}");
     }
 
+    #[test]
+    fn otherwise_expands_to_the_unlisted_labels() {
+        let pack = temp_pack("otherwise");
+        let source = ROUTED.replace(
+            "when = gate.area, answers = [\"frontend\"])",
+            "when = gate.area, otherwise = True)",
+        );
+        let compiled = compile_source(&source, &pack.join("workflow.star"), &pack).unwrap();
+        let when = |name: &str| {
+            compiled
+                .workflow
+                .tasks
+                .iter()
+                .find(|t| t.name.0 == name)
+                .unwrap()
+                .when
+                .as_ref()
+                .map(ToString::to_string)
+        };
+        assert_eq!(when("fix").as_deref(), Some("gate.area in scheduler"));
+        assert_eq!(
+            when("punt").as_deref(),
+            Some("gate.area in frontend"),
+            "uncertain is dropped by the question, so otherwise does not claim it"
+        );
+        let text = toml::to_string(&compiled.workflow).unwrap();
+        assert!(!text.contains("otherwise"), "{text}");
+        let _ = std::fs::remove_dir_all(&pack);
+    }
+
+    #[test]
+    fn otherwise_catches_uncertain_when_the_question_does_not_drop_it() {
+        let pack = temp_pack("otherwise-uncertain");
+        let source = ROUTED
+            .replace("            drop = [\"uncertain\"],\n", "")
+            .replace(
+                "when = gate.area, answers = [\"frontend\"])",
+                "when = gate.area, otherwise = True)",
+            );
+        let compiled = compile_source(&source, &pack.join("workflow.star"), &pack).unwrap();
+        let punt = compiled
+            .workflow
+            .tasks
+            .iter()
+            .find(|t| t.name.0 == "punt")
+            .unwrap();
+        assert_eq!(
+            punt.when.as_ref().unwrap().to_string(),
+            "gate.area in frontend|uncertain"
+        );
+        let _ = std::fs::remove_dir_all(&pack);
+    }
+
+    #[test]
+    fn otherwise_on_a_noul_takes_no_and_uncertain_in_place_of_the_yes_default() {
+        let pack = temp_pack("otherwise-noul");
+        let source = format!(
+            "{}\n",
+            ROUTED
+                .replace(", drop = [\"no\", \"uncertain\"])", ")")
+                .replace(
+                    "wrap = command(",
+                    "calm = command(name = \"calm\", run = \"./calm.sh\", depends_on = [gate], when = gate.urgent, otherwise = True, required = False)\nwrap = command(",
+                )
+                .replace("tasks = [classify, gate, fix, punt, page, wrap]", "tasks = [classify, gate, fix, punt, page, calm, wrap]")
+        );
+        let compiled = compile_source(&source, &pack.join("workflow.star"), &pack).unwrap();
+        let calm = compiled
+            .workflow
+            .tasks
+            .iter()
+            .find(|t| t.name.0 == "calm")
+            .unwrap();
+        assert_eq!(
+            calm.when.as_ref().unwrap().to_string(),
+            "gate.urgent in no|uncertain"
+        );
+        let _ = std::fs::remove_dir_all(&pack);
+    }
+
+    #[test]
+    fn two_otherwise_tasks_on_one_question_get_the_same_labels() {
+        let pack = temp_pack("otherwise-two");
+        let source = ROUTED
+            .replace(
+                "when = gate.area, answers = [\"frontend\"])",
+                "when = gate.area, otherwise = True)",
+            )
+            .replace(
+                "wrap = command(",
+                "note = command(name = \"note\", run = \"./note.sh\", depends_on = [gate], when = gate.area, otherwise = True, required = False)\nwrap = command(",
+            )
+            .replace("tasks = [classify, gate, fix, punt, page, wrap]", "tasks = [classify, gate, fix, punt, page, note, wrap]");
+        let compiled = compile_source(&source, &pack.join("workflow.star"), &pack).unwrap();
+        for name in ["punt", "note"] {
+            let task = compiled
+                .workflow
+                .tasks
+                .iter()
+                .find(|t| t.name.0 == name)
+                .unwrap();
+            assert_eq!(
+                task.when.as_ref().unwrap().to_string(),
+                "gate.area in frontend"
+            );
+        }
+        let _ = std::fs::remove_dir_all(&pack);
+    }
+
+    #[test]
+    fn an_unreachable_otherwise_is_an_error_at_its_argument() {
+        let source = ROUTED.replace(
+            "wrap = command(",
+            "rest = command(name = \"rest\", run = \"./rest.sh\", depends_on = [gate], when = gate.area, otherwise = True, required = False)\nwrap = command(",
+        ).replace("tasks = [classify, gate, fix, punt, page, wrap]", "tasks = [classify, gate, fix, punt, page, rest, wrap]");
+        let err = routed_error("otherwise-empty", &source);
+        assert!(err.contains("unreachable otherwise on \"rest\""), "{err}");
+        assert!(err.contains("gate.area"), "{err}");
+        let line = source
+            .lines()
+            .position(|l| l.starts_with("rest = "))
+            .unwrap();
+        let column = source.lines().nth(line).unwrap().find("otherwise").unwrap() + 1;
+        assert!(
+            err.contains(&format!("workflow.star:{}:{column}", line + 1)),
+            "{err}"
+        );
+    }
+
+    #[test]
+    fn otherwise_is_exclusive_with_answers_and_needs_when() {
+        let err = routed_error(
+            "otherwise-both",
+            &ROUTED.replace(
+                "answers = \"scheduler\")",
+                "answers = \"scheduler\", otherwise = True)",
+            ),
+        );
+        assert!(
+            err.contains("\"answers\" or \"otherwise\", not both"),
+            "{err}"
+        );
+        let err = routed_error(
+            "otherwise-no-when",
+            &ROUTED.replace(
+                "when = gate.area, answers = \"scheduler\")",
+                "otherwise = True)",
+            ),
+        );
+        assert!(
+            err.contains("\"otherwise\" has no meaning without \"when\""),
+            "{err}"
+        );
+    }
+
+    #[test]
+    fn an_empty_answers_list_is_refused_where_it_is_written() {
+        let err = routed_error(
+            "answers-empty",
+            &ROUTED.replace("answers = [\"frontend\"]", "answers = []"),
+        );
+        assert!(err.contains("\"answers\" lists no labels"), "{err}");
+        assert!(err.contains("workflow.star:16:"), "{err}");
+    }
+
     #[test]
     fn a_custom_workflow_has_the_route_constructors() {
         let pack = temp_pack("routed-custom");
@@ -3266,23 +3524,23 @@ workflow(type = "custom", tasks = [e], result = e)
             ),
             (
                 "agent",
-                "g = route(name = \"g\", source = None, min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\na = agent(name = \"a\", prompt = \"p\", depends_on = [g], required = False, when = g.q, answers = \"yes\"{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [a], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, a, w], result = w)\n",
+                "g = route(name = \"g\", source = None, min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\na = agent(name = \"a\", prompt = \"p\", depends_on = [g], required = False, when = g.q, answers = \"yes\", otherwise = False{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [a], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, a, w], result = w)\n",
             ),
             (
                 "skill",
-                "g = route(name = \"g\", min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\na = skill(name = \"a\", skill = \"skills/demo\", depends_on = [g], when = g.q, answers = \"yes\"{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [a], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, a, w], result = w)\n",
+                "g = route(name = \"g\", min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\na = skill(name = \"a\", skill = \"skills/demo\", depends_on = [g], when = g.q, answers = \"yes\", otherwise = False{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [a], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, a, w], result = w)\n",
             ),
             (
                 "command",
-                "g = route(name = \"g\", min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\nc = command(name = \"c\", run = \"true\", depends_on = [g], when = g.q, answers = \"yes\"{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [c], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, c, w], result = w)\n",
+                "g = route(name = \"g\", min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\nc = command(name = \"c\", run = \"true\", depends_on = [g], when = g.q, answers = \"yes\", otherwise = False{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [c], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, c, w], result = w)\n",
             ),
             (
                 "evaluate",
-                "g = route(name = \"g\", min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\ne = evaluate(name = \"e\", run = \"true\", depends_on = [g], when = g.q, answers = \"yes\"{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [e], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, e, w], result = w)\n",
+                "g = route(name = \"g\", min_confidence = 0.5, questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\ne = evaluate(name = \"e\", run = \"true\", depends_on = [g], when = g.q, answers = \"yes\", otherwise = False{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [e], join = \"settled\")\nworkflow(type = \"custom\", tasks = [g, e, w], result = w)\n",
             ),
             (
                 "route",
-                "u = command(name = \"u\", run = \"true\", emits = [\"q\", \"r\"])\ng = route(name = \"g\", source = u, min_confidence = None, depends_on = [u], required = True, join = \"all\", stage = \"iteration\", questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\nh = route(name = \"h\", source = u, depends_on = [u, g], when = g.q, answers = \"yes\", questions = {\"r\": noul(ask = \"r?\")}{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [h], join = \"settled\")\nworkflow(type = \"custom\", tasks = [u, g, h, w], result = w)\n",
+                "u = command(name = \"u\", run = \"true\", emits = [\"q\", \"r\"])\ng = route(name = \"g\", source = u, min_confidence = None, depends_on = [u], required = True, join = \"all\", stage = \"iteration\", questions = {\"q\": noul(ask = \"q?\", drop = [\"no\", \"uncertain\"])})\nh = route(name = \"h\", source = u, depends_on = [u, g], when = g.q, answers = \"yes\", otherwise = False, questions = {\"r\": noul(ask = \"r?\")}{extra})\nw = command(name = \"w\", run = \"true\", depends_on = [h], join = \"settled\")\nworkflow(type = \"custom\", tasks = [u, g, h, w], result = w)\n",
             ),
             (
                 "noul",
diff --git a/crucible/src/plan/starlark/error.rs b/crucible/src/plan/starlark/error.rs
index 2ff7df74..ada4e6e6 100644
--- a/crucible/src/plan/starlark/error.rs
+++ b/crucible/src/plan/starlark/error.rs
@@ -417,6 +417,14 @@ pub enum CompileError {
     WhenNotAnAnswer,
     #[error("argument \"answers\" has no meaning without \"when\"")]
     AnswersWithoutWhen,
+    #[error("argument \"answers\" lists no labels")]
+    EmptyAnswers,
+    #[error("argument \"otherwise\" has no meaning without \"when\"")]
+    OtherwiseWithoutWhen,
+    #[error("a task takes \"answers\" or \"otherwise\", not both")]
+    OtherwiseWithAnswers,
+    #[error("unreachable otherwise on {task:?}: every answer of {asked} is listed or dropped")]
+    UnreachableOtherwise { task: String, asked: String },
     #[error(
         "{asked} cannot answer {label:?}{} (it answers: {declared})",
         diag::hint(.suggestion.as_deref())
diff --git a/crucible/src/plan/starlark/idents.rs b/crucible/src/plan/starlark/idents.rs
index 8b4a30ce..fdf6ee43 100644
--- a/crucible/src/plan/starlark/idents.rs
+++ b/crucible/src/plan/starlark/idents.rs
@@ -145,7 +145,12 @@ pub(crate) fn narrow(error: CompileError, idents: &Idents) -> CompileError {
             (None, "session")
         }
         CompileError::WhenNotAnAnswer => (None, "when"),
-        CompileError::UnknownAnswer { .. } | CompileError::AnswersWithoutWhen => (None, "answers"),
+        CompileError::UnknownAnswer { .. }
+        | CompileError::AnswersWithoutWhen
+        | CompileError::EmptyAnswers => (None, "answers"),
+        CompileError::OtherwiseWithoutWhen
+        | CompileError::OtherwiseWithAnswers
+        | CompileError::UnreachableOtherwise { .. } => (None, "otherwise"),
         CompileError::RouteDecider { .. } => (Some("route"), "name"),
         _ => {
             return CompileError::At { at, inner };
diff --git a/crucible/src/plan/starlark/reference.rs b/crucible/src/plan/starlark/reference.rs
index 780ebe53..25c4107f 100644
--- a/crucible/src/plan/starlark/reference.rs
+++ b/crucible/src/plan/starlark/reference.rs
@@ -136,6 +136,7 @@ fn task_knobs() -> Vec<Kwarg> {
         ),
         when_kwarg(),
         answers_kwarg(),
+        otherwise_kwarg(),
     ]
 }
 
@@ -150,6 +151,18 @@ fn when_kwarg() -> Kwarg {
     )
 }
 
+fn otherwise_kwarg() -> Kwarg {
+    Kwarg::new(
+        "otherwise",
+        "bool",
+        format!(
+            "In place of `answers`: every answer no other task lists and the question does not \
+             `drop`, `\"{UNCERTAIN}\"` included. Expanded at compile time. An unreachable \
+             `otherwise` is an error."
+        ),
+    )
+}
+
 fn answers_kwarg() -> Kwarg {
     Kwarg::new(
         "answers",
@@ -473,6 +486,7 @@ pub fn functions() -> Vec<Function> {
                 Kwarg::new("stage", "\"iteration\" | \"epilogue\"", "As on any task."),
                 when_kwarg(),
                 answers_kwarg(),
+                otherwise_kwarg(),
             ],
         },
         Function {
diff --git a/docs/dsl-reference.md b/docs/dsl-reference.md
index 2a359708..0fbd243e 100644
--- a/docs/dsl-reference.md
+++ b/docs/dsl-reference.md
@@ -38,6 +38,7 @@ An agent turn driven by a prompt.
 | `stage` | `"iteration" \| "epilogue"` | `epilogue` runs once after the loop concludes, and only if the run kept a candidate. |
 | `when` | `route.question` | Run only on a listed answer to one question of a `route()` this task depends on. Otherwise the task settles `not_taken`: no dispatch, no spend, no effect on validity, and every `all`-join dependent is not taken with it. Rejoin branches with `join = "passed"` or `join = "settled"`. Playbook and custom workflows only. |
 | `answers` | `str \| list[str]` | The answers `when` accepts: labels the question declares, or `"uncertain"`. Defaults to `"yes"` for a noul and is required for a choice. |
+| `otherwise` | `bool` | In place of `answers`: every answer no other task lists and the question does not `drop`, `"uncertain"` included. Expanded at compile time. An unreachable `otherwise` is an error. |
 
 ### `skill()`
 
@@ -66,6 +67,7 @@ An agent turn whose prompt is a skill's instructions plus its arguments.
 | `stage` | `"iteration" \| "epilogue"` | `epilogue` runs once after the loop concludes, and only if the run kept a candidate. |
 | `when` | `route.question` | Run only on a listed answer to one question of a `route()` this task depends on. Otherwise the task settles `not_taken`: no dispatch, no spend, no effect on validity, and every `all`-join dependent is not taken with it. Rejoin branches with `join = "passed"` or `join = "settled"`. Playbook and custom workflows only. |
 | `answers` | `str \| list[str]` | The answers `when` accepts: labels the question declares, or `"uncertain"`. Defaults to `"yes"` for a noul and is required for a choice. |
+| `otherwise` | `bool` | In place of `answers`: every answer no other task lists and the question does not `drop`, `"uncertain"` included. Expanded at compile time. An unreachable `otherwise` is an error. |
 
 ### `command()`
 
@@ -89,6 +91,7 @@ A deterministic shell task in the candidate workspace.
 | `stage` | `"iteration" \| "epilogue"` | `epilogue` runs once after the loop concludes, and only if the run kept a candidate. |
 | `when` | `route.question` | Run only on a listed answer to one question of a `route()` this task depends on. Otherwise the task settles `not_taken`: no dispatch, no spend, no effect on validity, and every `all`-join dependent is not taken with it. Rejoin branches with `join = "passed"` or `join = "settled"`. Playbook and custom workflows only. |
 | `answers` | `str \| list[str]` | The answers `when` accepts: labels the question declares, or `"uncertain"`. Defaults to `"yes"` for a noul and is required for a choice. |
+| `otherwise` | `bool` | In place of `answers`: every answer no other task lists and the question does not `drop`, `"uncertain"` included. Expanded at compile time. An unreachable `otherwise` is an error. |
 
 ### `evaluate()`
 
@@ -114,6 +117,7 @@ A measurement command. Its last non-empty stdout line is a JSON object; `pass =
 | `stage` | `"iteration" \| "epilogue"` | `epilogue` runs once after the loop concludes, and only if the run kept a candidate. |
 | `when` | `route.question` | Run only on a listed answer to one question of a `route()` this task depends on. Otherwise the task settles `not_taken`: no dispatch, no spend, no effect on validity, and every `all`-join dependent is not taken with it. Rejoin branches with `join = "passed"` or `join = "settled"`. Playbook and custom workflows only. |
 | `answers` | `str \| list[str]` | The answers `when` accepts: labels the question declares, or `"uncertain"`. Defaults to `"yes"` for a noul and is required for a choice. |
+| `otherwise` | `bool` | In place of `answers`: every answer no other task lists and the question does not `drop`, `"uncertain"` included. Expanded at compile time. An unreachable `otherwise` is an error. |
 
 ### `report()`
 
@@ -254,6 +258,7 @@ Engine-owned decision: answers typed questions about its dependencies' outputs a
 | `stage` | `"iteration" \| "epilogue"` | As on any task. |
 | `when` | `route.question` | Run only on a listed answer to one question of a `route()` this task depends on. Otherwise the task settles `not_taken`: no dispatch, no spend, no effect on validity, and every `all`-join dependent is not taken with it. Rejoin branches with `join = "passed"` or `join = "settled"`. Playbook and custom workflows only. |
 | `answers` | `str \| list[str]` | The answers `when` accepts: labels the question declares, or `"uncertain"`. Defaults to `"yes"` for a noul and is required for a choice. |
+| `otherwise` | `bool` | In place of `answers`: every answer no other task lists and the question does not `drop`, `"uncertain"` included. Expanded at compile time. An unreachable `otherwise` is an error. |
 
 ### `noul()`
 
diff --git a/docs/rfc/RFC-0001.md b/docs/rfc/RFC-0001.md
index 5ddf2dc6..43d26c9e 100644
--- a/docs/rfc/RFC-0001.md
+++ b/docs/rfc/RFC-0001.md
@@ -1,5 +1,5 @@
 <!-- GENERATED: do not edit. Source: RFC-0001 -->
-<!-- SIGNATURE: sha256:abd9863b8a7ebbfc0cc149f8f9d09534fc3b7878bf1b4843e69b0cec89d9a5c7 -->
+<!-- SIGNATURE: sha256:00243abaccb40eb17bd2e29baa525f7d475208bb95cf7f88ce54d293742767d5 -->
 
 # RFC-0001: Crucible implementation contract
 
@@ -296,6 +296,8 @@ The engine must reach the decision model through the broker, at an endpoint and
 
 Any task may declare when, a predicate over one question of one route task it depends on, satisfied when that question's resolved label is among the labels the predicate lists. Validation must reject a when that names a task that is not a route, a task outside the declaring task's dependencies, an unknown question, an empty label list, or a label that is neither declared by the question nor "uncertain", each with a diagnostic at the argument and a did-you-mean over the declared names. Every label of a routed question, including "uncertain", must either be listed by at least one when or be named in that question's drop list, so an answer that leads nowhere is one the author wrote down rather than one they forgot. A drop list must name only that question's labels or "uncertain". A question no when refers to is exempt.
 
+A task may declare otherwise in place of answers. The compiler must expand it to the question's labels, "uncertain" included, that no other task's when lists and the drop list does not name, and must write that list to the generated TOML. Tasks declaring otherwise on the same question get the same list. An otherwise that expands to nothing, otherwise with answers, otherwise without when, and an empty answers list must each be a compile error at that argument.
+
 A task that revises another under [RFC-0002:C-REVISE-LOOP](../rfc/RFC-0002.md#rfc-0002c-revise-loop) must not declare when: a reviewer runs whenever what it revises does, so the condition belongs on the revised task, and validation must reject the reviewer's. When a revised task settles not taken no round starts, and its reviewer settles not taken with it.
 
 A task whose when is not satisfied must settle as not taken, without dispatch and without spend. A when over a route that itself settled not taken is not satisfied. A when over a route that settled any other way without passing is not satisfied either, except that a task joining "all" on that route is blocked by the failure as any dependent is. Not taken is a terminal status distinct from skipped. It must not count against validity, must not short-circuit the run, and must not be reported as a failure. A task joining "all" on a dependency that settled not taken must itself settle not taken, so an untaken branch is untaken to its leaves. A task joining "passed" or "settled" is dispatched as those joins already define, and is how branches rejoin. A required task is required when taken: if its when is satisfied it gates validity as any required task does. The workflow's result task must not be conditional and must not be able to settle not taken through "all" joins alone.
@@ -333,6 +335,7 @@ Admit the playbook lane
 - route, noul, choice constructors and the when predicate; not-taken terminal status (C-ROUTE)
 - a route decides from a model or, deterministically, from a dependency's output
 - injected inference bindings, one typed document for every model the engine or its sandboxes reach (C-INFERENCE)
+- otherwise, resolved by the compiler to the answers no other task lists
 
 #### Changed
 
diff --git a/examples/route/workflow.star b/examples/route/workflow.star
index e2fe2376..2de4734f 100644
--- a/examples/route/workflow.star
+++ b/examples/route/workflow.star
@@ -26,13 +26,12 @@ oncall = command(name = "oncall", run = "./act.sh oncall", depends_on = [gate],
 
 finance = command(name = "finance", run = "./act.sh finance", depends_on = [gate], when = gate.bucket, answers = "billing")
 
-# A low-confidence read lands with a human, the same as a feature request.
 backlog = command(
     name = "backlog",
     run = "./act.sh backlog",
     depends_on = [gate],
     when = gate.bucket,
-    answers = ["feature", "uncertain"],
+    otherwise = True,
 )
 
 filed = command(
diff --git a/gov/rfc/RFC-0001/clauses/C-ROUTE.toml b/gov/rfc/RFC-0001/clauses/C-ROUTE.toml
index fabf4e3c..3293c7a4 100644
--- a/gov/rfc/RFC-0001/clauses/C-ROUTE.toml
+++ b/gov/rfc/RFC-0001/clauses/C-ROUTE.toml
@@ -23,6 +23,8 @@ The engine must reach the decision model through the broker, at an endpoint and
 
 Any task may declare when, a predicate over one question of one route task it depends on, satisfied when that question's resolved label is among the labels the predicate lists. Validation must reject a when that names a task that is not a route, a task outside the declaring task's dependencies, an unknown question, an empty label list, or a label that is neither declared by the question nor "uncertain", each with a diagnostic at the argument and a did-you-mean over the declared names. Every label of a routed question, including "uncertain", must either be listed by at least one when or be named in that question's drop list, so an answer that leads nowhere is one the author wrote down rather than one they forgot. A drop list must name only that question's labels or "uncertain". A question no when refers to is exempt.
 
+A task may declare otherwise in place of answers. The compiler must expand it to the question's labels, "uncertain" included, that no other task's when lists and the drop list does not name, and must write that list to the generated TOML. Tasks declaring otherwise on the same question get the same list. An otherwise that expands to nothing, otherwise with answers, otherwise without when, and an empty answers list must each be a compile error at that argument.
+
 A task that revises another under [[RFC-0002:C-REVISE-LOOP]] must not declare when: a reviewer runs whenever what it revises does, so the condition belongs on the revised task, and validation must reject the reviewer's. When a revised task settles not taken no round starts, and its reviewer settles not taken with it.
 
 A task whose when is not satisfied must settle as not taken, without dispatch and without spend. A when over a route that itself settled not taken is not satisfied. A when over a route that settled any other way without passing is not satisfied either, except that a task joining "all" on that route is blocked by the failure as any dependent is. Not taken is a terminal status distinct from skipped. It must not count against validity, must not short-circuit the run, and must not be reported as a failure. A task joining "all" on a dependency that settled not taken must itself settle not taken, so an untaken branch is untaken to its leaves. A task joining "passed" or "settled" is dispatched as those joins already define, and is how branches rejoin. A required task is required when taken: if its when is satisfied it gates validity as any required task does. The workflow's result task must not be conditional and must not be able to settle not taken through "all" joins alone.
diff --git a/gov/rfc/RFC-0001/rfc.toml b/gov/rfc/RFC-0001/rfc.toml
index d3893aba..08b4e53e 100644
--- a/gov/rfc/RFC-0001/rfc.toml
+++ b/gov/rfc/RFC-0001/rfc.toml
@@ -45,6 +45,7 @@ added = [
     "route, noul, choice constructors and the when predicate; not-taken terminal status (C-ROUTE)",
     "a route decides from a model or, deterministically, from a dependency's output",
     "injected inference bindings, one typed document for every model the engine or its sandboxes reach (C-INFERENCE)",
+    "otherwise, resolved by the compiler to the answers no other task lists",
 ]
 changed = [
     "DSL grammar admits dictionaries, conditionals, comprehensions, iteration, user-defined functions, load() and the pure standard library",
diff --git a/gov/work/2026-09-21-let-a-task-take-whatever-answers-no-other-task-lists.toml b/gov/work/2026-09-21-let-a-task-take-whatever-answers-no-other-task-lists.toml
new file mode 100644
index 00000000..a70ed557
--- /dev/null
+++ b/gov/work/2026-09-21-let-a-task-take-whatever-answers-no-other-task-lists.toml
@@ -0,0 +1,30 @@
+#:schema ../schema/work.schema.json
+
+[govctl]
+id = "WI-2026-09-21-002"
+title = "Let a task take whatever answers no other task lists"
+status = "active"
+created = "2026-09-21"
+started = "2026-09-21"
+refs = [
+    "RFC-0001:C-ROUTE",
+    "RFC-0001:C-WORKFLOW",
+]
+
+[content]
+description = "`otherwise = True` on a task's `when` expands at compile time to the question's labels that no other task lists and the question does not drop. The generated TOML carries the expanded list."
+
+[[content.acceptance_criteria]]
+text = "otherwise = True expands to the unlisted, undropped labels, uncertain included; the generated TOML has the list and no otherwise"
+status = "pending"
+category = "added"
+
+[[content.acceptance_criteria]]
+text = "compile errors at the argument for an unreachable otherwise, otherwise with answers, otherwise without when, and answers = []"
+status = "pending"
+category = "added"
+
+[[content.acceptance_criteria]]
+text = "DSL reference entry and the route example"
+status = "pending"
+category = "chore"