diff --git a/AGENTS.md b/AGENTS.md
index 586fb818..7b680bc4 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -4,7 +4,7 @@ Guidance for AI agents (Claude Code, Codex, etc.) working in this repository. `C
 
 ## Project Overview
 
-dotbot is a structured AI-assisted development framework built entirely in **PowerShell 7+**. It wraps AI coding workflows in managed, auditable processes with two-phase execution (analysis → implementation), per-task git worktree isolation, and a web dashboard for monitoring.
+dotbot is a structured AI-assisted development framework built entirely in **PowerShell 7+**. It wraps AI coding workflows in managed, auditable processes with single-session task execution, per-task git worktree isolation, and a web dashboard for monitoring.
 
 ## Commands
 
@@ -61,10 +61,9 @@ The PowerShell framework (`src/runtime/`, `src/mcp/`, `src/ui/`, `src/cli/`, `sr
 
 `src/runtime/Modules/ContentResolver/` implements project-over-framework lookup. A project can override any content item (agents/skills/prompts/workflows/stacks/recipes) by placing it under `<BotRoot>/content/<Type>/`, or override hook scripts by placing them under `<BotRoot>/hooks/<verify|dev|scripts>/`; the runtime falls back to `<DOTBOT_HOME>` otherwise. Merge is by filename — a project file replaces the framework file of the same name; framework-only files still run. APIs: `Resolve-DotbotContent`, `Get-DotbotContentItems`, `Get-DotbotHookChain`.
 
-### Two-phase execution
+### Single-session execution
 
-1. **Analysis** (`98-analyse-task.md`): explores codebase, builds context package, may propose splits. Task: `todo → analysing → analysed`.
-2. **Implementation** (`99-autonomous-task.md`): consumes context, writes code, tests, commits with `[task:XXXXXXXX]` tag. Task: `analysed → in-progress → done`.
+Each task runs in one provider session driven by `100-single-session-task.md`. That session handles discovery, implementation, verification, and commit (with a `[task:XXXXXXXX]` tag), then marks the task done. If human input is needed it pauses on `needs-input` and resumes the same task. Task lifecycle: `todo -> analysing -> analysed -> in-progress -> done`; the task-runner auto-promotes through `analysing`/`analysed` (there is no separate analysis provider session).
 
 ### Git worktree isolation
 
diff --git a/README.md b/README.md
index 6fcdad19..98ad9ed3 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ dotbot wraps AI-assisted coding in a managed, transparent workflow where every s
 - **Workflows and stacks** - **Workflows** (e.g. `start-from-jira`) define operational pipelines - what dotbot does. **Stacks** (e.g. `dotnet`, `dotnet-blazor`) add tech-specific skills, hooks, and MCP tools - what tech the project uses. Stacks compose additively with `extends` chains. Settings deep-merge across `default -> workflows -> stacks`.
 
 ### Execution engine
-- **Two-phase execution** - Analysis resolves ambiguity, identifies files, and builds a context package. Implementation consumes that package and writes code. Tasks flow: `todo -> analysing -> analysed -> in-progress -> done`.
+- **Single-session execution** - Each task runs in one provider session that does discovery, implementation, verification, and commit, pausing only when human input is needed. Tasks flow: `todo -> analysing -> analysed -> in-progress -> done`.
 - **Per-task git worktree isolation** - Each task runs in its own worktree on an isolated branch, squash-merged back to main on completion.
 - **Per-task model selection** - Tasks can specify a model (e.g. Sonnet for simple tasks, Opus for complex ones) that overrides the process-level default. Use cheaper models where they suffice to reduce token spend.
 - **Multi-slot concurrent execution** - The workflow engine runs multiple tasks from the same workflow in parallel with slot-aware locking, shortening wall-clock time for large task queues.
diff --git a/content/prompts/00-interview.md b/content/prompts/00-interview.md
new file mode 100644
index 00000000..62de6751
--- /dev/null
+++ b/content/prompts/00-interview.md
@@ -0,0 +1,84 @@
+# Clarification Interview
+
+You are conducting a clarification interview for a software project. The user's
+short project description appears below. Each round, decide one thing: do you
+have enough clarity to proceed, or must you ask the user targeted questions
+first?
+
+Each round you write EXACTLY ONE file to `.bot/workspace/product/`:
+
+- `clarification-questions.json` -- you still need answers. The loop pauses,
+  collects the user's answers, then runs you again with those answers in
+  context.
+- `interview-summary.md` -- you have enough clarity. The interview ends.
+
+NEVER write both in the same round. Do not write any other files (no
+`mission.md`, no `tech-stack.md`). Do not use task-management tools.
+
+## When to ask vs finish
+
+Ask a question only when a genuine ambiguity would change the design, scope, or
+technology AND you cannot resolve it from the description, the briefing files,
+or previous rounds. Finish when the only unknowns left are ordinary
+implementation details a developer can settle later.
+
+If a previous round already answered a question, do NOT re-ask it. Build on the
+answer.
+
+## clarification-questions.json schema
+
+The loop validates this file strictly. A malformed file fails the task. Match
+this shape exactly:
+
+{
+  "questions": [
+    {
+      "id": "q1",
+      "question": "One clear, specific question. Do not inline the choices here.",
+      "context": "Why this matters -- what is ambiguous and what the answer changes.",
+      "options": [
+        { "key": "A", "label": "First option, short noun phrase", "rationale": "Why you might pick this" },
+        { "key": "B", "label": "Second option", "rationale": "Why you might pick this" }
+      ],
+      "recommendation": "A"
+    }
+  ]
+}
+
+Hard rules (the validator rejects the file otherwise):
+
+- `questions` is a non-empty array.
+- Each question has a non-empty `question` string.
+- `options` is REQUIRED and is an array of OBJECTS. Never plain strings. Never
+  inline the choices as text in the `question` field.
+- Each option is an object with `key` and `label`. `key` is a single uppercase
+  letter: A, B, C, D, or E, unique within the question. `label` is a non-empty
+  short phrase. `rationale` is optional but recommended.
+- Each question has 2 to 5 options.
+- `recommendation`, if present, must equal one of the option keys. Put the
+  recommended choice as option `A`.
+- `context` is optional but recommended.
+
+Ask only as many questions as genuinely needed. Fewer, sharper questions beat
+many shallow ones.
+
+## interview-summary.md format
+
+When you have enough clarity, write a short markdown summary:
+
+# Interview Summary
+
+## Project
+One paragraph restating what is being built.
+
+## Key Decisions
+- Bullet the choices that are now settled (from the description, the briefing,
+  or answered questions).
+
+## Clarification Log
+One row per answered question across all rounds. Omit this whole section if no
+questions were ever asked.
+
+| # | Question | Answer | Interpretation |
+|---|----------|--------|----------------|
+| q1 | ... | ... | ... |
diff --git a/content/prompts/100-single-session-task.md b/content/prompts/100-single-session-task.md
index 8e6ecc72..8378d6d4 100644
--- a/content/prompts/100-single-session-task.md
+++ b/content/prompts/100-single-session-task.md
@@ -12,12 +12,12 @@ You are an autonomous AI coding agent. Complete this task in the current provide
 
 Built-in tools (`Read`, `Write`, `Edit`, `Bash`, `Glob`, `Grep`, `WebSearch`, `WebFetch`) are always available. Do not use ToolSearch for them.
 
-The Bash tool runs Bash, not PowerShell. If you need PowerShell semantics, run `pwsh -Command "<script>"` explicitly.
+The Bash tool runs Bash, not PowerShell. Do not use `$obj.property`, `$_.Name`, `Get-ChildItem`, or `Where-Object`. Use `jq` for JSON, `awk` or `cut` for fields, `$(command)` for substitution, `grep` and `find` for filtering. If you need PowerShell semantics, run `pwsh -Command "<script>"` explicitly.
 
 Load dotbot tools once:
 
 ```
-ToolSearch({ query: "select:mcp__dotbot__task_get_context,mcp__dotbot__task_set_status,mcp__dotbot__task_update,mcp__dotbot__plan_get,mcp__dotbot__plan_create,mcp__dotbot__task_mark_needs_review,mcp__dotbot__steering_heartbeat" })
+ToolSearch({ query: "select:mcp__dotbot__task_get_context,mcp__dotbot__task_set_status,mcp__dotbot__task_update,mcp__dotbot__plan_get,mcp__dotbot__plan_create,mcp__dotbot__task_mark_needs_review,mcp__dotbot__steering_heartbeat,mcp__dotbot__decision_list,mcp__dotbot__decision_get" })
 ```
 
 If the exact `select:` query returns no schemas, wait briefly and retry the exact same query once. Do not broaden the search.
@@ -75,6 +75,26 @@ If `resume_context` is present:
 
 If `resume_context` is absent, do focused discovery only. Read the smallest useful set of files before editing.
 
+## Decisions
+
+Accepted decisions are binding constraints. Honour them while you implement; do not contradict or re-litigate them.
+
+After `task_get_context` returns:
+
+1. If the task has `applicable_decisions` set, read each one:
+
+   ```
+   mcp__dotbot__decision_get({ decision_id: "dec-XXXXXXXX" })
+   ```
+
+2. If `applicable_decisions` is empty, list accepted decisions and keep the ones whose `decision` or `consequences` bear on this task's entities or category:
+
+   ```
+   mcp__dotbot__decision_list({ status: "accepted" })
+   ```
+
+The list also contains **inbound decisions** (tagged `inbound:mothership`, `inbound:registry`, or `inbound:settings`) captured from external answers, workflow changes, and settings changes. Treat them the same as locally-authored decisions. The log is append-only and grows over time, so filter by relevance: include an inbound decision only when its `related_task_ids` names this task, or its `decision`/`consequences` clearly bears on this task. Apply each relevant decision's `decision` and `consequences` as a hard constraint.
+
 ## Working Directory
 
 You are in a task worktree on branch `{{BRANCH_NAME}}`. Commit to this branch and do not push. The framework squash-merges it.
diff --git a/content/prompts/98-analyse-task.md b/content/prompts/98-analyse-task.md
deleted file mode 100644
index 37764327..00000000
--- a/content/prompts/98-analyse-task.md
+++ /dev/null
@@ -1,601 +0,0 @@
----
-{
-  "name": "Pre-flight Task Analysis",
-  "description": "Template for 98-Analyse workflow - front-load research before implementation",
-  "version": 1
-}
----
-# Pre-flight Task Analysis
-
-You are an autonomous AI coding agent performing **pre-flight analysis** of a task. Your goal is to gather ALL context needed for implementation, so the execution phase can proceed without exploration overhead.
-
-## Phase 0: Load Required Tools
-
-**Built-in tools** (`WebSearch`, `WebFetch`, `Read`, `Write`, `Edit`, `Bash`, `Glob`, `Grep`) are always available — never use ToolSearch for them.
-
-> The Bash tool runs Bash, not PowerShell. Do not use `$obj.property`, `$_.Name`, `Get-ChildItem`, or `Where-Object`. Use `jq` for JSON, `awk` or `cut` for fields, `$(command)` for substitution, `grep` and `find` for filtering. If you need PowerShell semantics, run `pwsh -Command "<script>"` explicitly.
-
-**Load dotbot tools** (single bulk call — `select:` accepts a comma-separated list):
-
-```
-ToolSearch({ query: "select:mcp__dotbot__task_set_status,mcp__dotbot__task_update,mcp__dotbot__decision_create,mcp__dotbot__decision_list,mcp__dotbot__decision_get,mcp__dotbot__plan_get,mcp__dotbot__plan_create" })
-```
-
-Issue this ToolSearch call once during Phase 0. Do **NOT** broaden the query, split it across multiple calls, or try alternative search terms. If the bulk `select:` query returns no schemas on the first attempt, the dotbot MCP server is still warming up — while **still in Phase 0**, wait briefly and retry the **exact same** `select:` call. Once Phase 0 is complete, do not call ToolSearch again. If you see any `mcp__dotbot__*` tool listed as deferred in your initial tool list, that is expected — ToolSearch loads the schema on demand. Do NOT refuse on the grounds that these tools are "missing".
-
-**Do not call `mcp__dotbot__task_get_context` during analysis.** All task fields you need are already substituted into this prompt above ({{TASK_DESCRIPTION}}, {{ACCEPTANCE_CRITERIA}}, {{TASK_STEPS}}, {{APPLICABLE_AGENTS}}, {{APPLICABLE_STANDARDS}}). `task_get_context` is for the execution phase (99-autonomous-task) where it returns the analysed package back. Calling it during analysis succeeds but returns minimal context — skip the call.
-
----
-
-## Session Context
-
-- **Session ID:** {{SESSION_ID}}
-- **Task ID:** {{TASK_ID}}
-- **Task Name:** {{TASK_NAME}}
-
-## Agent Context
-
-**Persona** — read this file and embody the described role throughout your analysis:
-{{APPLICABLE_AGENTS}}
-
-**Skills** — read and apply these skill guides during analysis:
-{{APPLICABLE_SKILLS}}
-
-## Working Directory
-
-You are working in the task worktree on branch `{{BRANCH_NAME}}`. This is the
-same branch that implementation will use after analysis.
-- Do NOT modify code files — you are preparing, not implementing
-- The .bot/ MCP tools access the central task queue
-
-## Task Details
-
-**Category:** {{TASK_CATEGORY}}
-**Priority:** {{TASK_PRIORITY}}
-**Effort:** {{TASK_EFFORT}}
-**Needs Interview:** {{NEEDS_INTERVIEW}}
-
-### Description
-{{TASK_DESCRIPTION}}
-
-### Acceptance Criteria
-{{ACCEPTANCE_CRITERIA}}
-
-### Implementation Steps (if any)
-{{TASK_STEPS}}
-
----
-
-## Your Mission
-
-Front-load ALL research and context gathering so the implementation phase (99-autonomous-task) can execute efficiently without exploration. You are NOT implementing - you are preparing.
-
-**Key Outputs:**
-1. Identify affected entities from the domain model
-2. Discover which files need modification
-3. Validate dependencies are met
-4. Map applicable standards
-5. Create implementation guidance
-6. Ask clarifying questions if ambiguous
-7. Propose splits if task is too large
-
----
-
-## Analysis Protocol
-
-### Phase 1: Mark Task In Analysis
-
-```
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "analysing" })
-```
-
-This signals the task is being analysed and prevents others from picking it up.
-
-### Phase 1.5: User Interview (If Requested)
-
-**Needs Interview: {{NEEDS_INTERVIEW}}**
-
-If `needs_interview` is `true`:
-
-1. **Review the task description** and identify areas needing clarification:
-   - Ambiguous requirements
-   - Missing context or constraints
-   - Unclear acceptance criteria
-   - Scope questions
-
-2. **Ask clarifying questions** using the `task_update` → `task_set_status` pause pattern:
-   - Ask ONE focused question at a time
-   - Provide 3-5 options where applicable (Option A = recommendation)
-   - Wait for answer before asking next question
-
-3. **Capture decisions from answers:** After each answer, evaluate whether it constitutes a reusable decision (real trade-off, rejected alternatives, cross-task impact). This includes architectural, business, technical, and process decisions. If so, record it:
-   ```javascript
-   mcp__dotbot__decision_create({
-     title: "Short noun-phrase title of the decision",
-     context: "Why this question arose — the forces at play",
-     decision: "The specific choice the user made",
-     consequences: "What this constrains for this and other tasks",
-     alternatives_considered: [
-       { option: "The rejected option", reason_rejected: "Why it was rejected" }
-     ],
-     status: "accepted",
-     type: "architecture",  // one of: architecture, business, technical, process
-     impact: "medium",
-     tags: ["task-derived"],
-     related_task_ids: ["{{TASK_ID}}"]
-   })
-   ```
-   Only create decisions for answers with genuine cross-task weight — skip simple preferences or obvious defaults.
-
-4. **Proceed to Phase 2** only when requirements are sufficiently clear
-
-**Example interview question** (two calls — record the question, then pause the task):
-```
-mcp__dotbot__task_update({
-  task_id: "{{TASK_ID}}",
-  extensions: {
-    runner: {
-      pending_question: {
-        question: "What is the primary goal of this feature?",
-        context: "The task description mentions several possibilities. Clarifying the main intent will help scope the implementation.",
-        multi_select: false,
-        options: [
-          { key: "A", label: "Option A (recommended)", rationale: "Most common interpretation based on task wording" },
-          { key: "B", label: "Alternative approach", rationale: "If you meant something different" },
-          { key: "C", label: "Both options", rationale: "Implement both capabilities" },
-          { key: "D", label: "Something else", rationale: "Provide clarification" }
-        ],
-        recommendation: "A"
-      }
-    }
-  }
-})
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "needs-input" })
-```
-
-If `needs_interview` is `false`: Skip directly to Phase 2.
-
-### Phase 2: Entity Detection
-
-Read the entity model and identify entities involved in this task.
-
-**Skip-if-produced guard.** Before issuing the Read below, check the current task's `outputs` list (from the task JSON returned by `task_get_context` or visible on the task file). If `entity-model.md` is one of this task's declared outputs, **skip this read** — the file is what the task is being asked to produce and will not exist yet. Fall through to the next step and derive entity context from briefing material or PRD instead. The same rule applies to `mission.md` and `tech-stack.md` reads elsewhere in this prompt.
-
-1. **Read entity model (skip if in task `outputs`):**
-   ```
-   Read({ file_path: ".bot/workspace/product/entity-model.md" })
-   ```
-
-2. **Identify entities:**
-   - Primary entities: Directly affected by this task
-   - Related entities: May be impacted indirectly
-   - Create a context summary explaining how entities relate
-
-**Example output:**
-```json
-{
-  "entities": {
-    "primary": ["CalendarEvent", "EventRecurrence"],
-    "related": ["User", "Notification"],
-    "context_summary": "CalendarEvent is the main entity. EventRecurrence handles repeating events. User owns events, Notification is triggered on changes."
-  }
-}
-```
-
-### Phase 3: File Discovery
-
-Discover all files relevant to implementation.
-
-1. **Search for existing implementations:**
-   ```
-   grep({ queries: ["EntityName", "ClassName"], path: "." })
-   ```
-
-2. **Find pattern files:**
-   Use `codebase_semantic_search` to find similar implementations you can use as patterns.
-
-3. **Identify test files:**
-   Find corresponding test files that need updating.
-
-**Categorize files:**
-- `to_modify`: Files that need changes
-- `patterns_from`: Files with patterns to follow (don't modify, just reference)
-- `tests_to_update`: Test files requiring updates
-
-**Example output:**
-```json
-{
-  "files": {
-    "to_modify": ["src/Domain/CalendarEvent.cs", "src/Data/CalendarEventRepository.cs"],
-    "patterns_from": ["src/Domain/Task.cs", "src/Data/TaskRepository.cs"],
-    "tests_to_update": ["tests/Domain/CalendarEventTests.cs"]
-  }
-}
-```
-
-### Phase 4: Dependency Validation
-
-Check that all task dependencies are met.
-
-1. **Check explicit dependencies:**
-   If the task has listed dependencies, verify they're complete (in `done/` folder).
-
-2. **Discover implicit dependencies:**
-   While exploring, note if you find code that should exist but doesn't.
-
-3. **Identify blocking issues:**
-   Are there any issues that would block implementation?
-
-**Example output:**
-```json
-{
-  "dependencies": {
-    "task_dependencies": ["task-id-1", "task-id-2"],
-    "implicit_dependencies": ["CalendarEvent entity must exist before adding recurrence"],
-    "blocking_issues": []
-  }
-}
-```
-
-### Phase 5: Standards and Decision Mapping
-
-Identify which coding standards and decision constraints apply to this task.
-
-**Pre-specified standards from task configuration** (use as your starting point):
-{{APPLICABLE_STANDARDS}}
-
-Read whatever standards the section above lists. Do not probe `.bot/recipes/standards/global/` — that directory is optional and absent in most workflows; the runtime already supplies the relevant set above.
-
-1. **Determine applicable standards:**
-   Based on task category and files involved, narrow the substituted set above to the standards relevant to this task.
-
-2. **Load applicable decisions:**
-   If the task has `applicable_decisions` set, read each one:
-   ```javascript
-   mcp__dotbot__decision_get({ decision_id: "dec-XXXXXXXX" })
-   ```
-   If `applicable_decisions` is empty, call `mcp__dotbot__decision_list({ status: "accepted" })` and include any decisions whose consequences are relevant to this task's entities or category.
-   Also include any decisions you created during Phase 1.5 or Phase 8 question resolution — these are already linked to this task.
-
-3. **Extract relevant sections:**
-   Note which specific sections of each standard are most relevant. For decisions, extract `decision` and `consequences` — these are the binding constraints.
-
-**Example output:**
-```json
-{
-  "standards": {
-    "applicable": ["standards/entity-framework.md"],
-    "relevant_sections": {
-      "standards/entity-framework.md": ["Configuration patterns", "Migrations"]
-    }
-  },
-  "decisions": [
-    {
-      "id": "dec-XXXXXXXX",
-      "title": "Scope to Titan Platform Only",
-      "decision": "All implementation targets Titan only. FinApps integration is deferred.",
-      "consequences": "Do not introduce FinApps dependencies. Acceptance criteria validate Titan only."
-    }
-  ]
-}
-```
-
-### Phase 6: Product Context Extraction
-
-Extract ONLY the product context needed for this task.
-
-**Skip-if-produced guard.** As in Phase 2, if `mission.md` appears in the current task's `outputs` list, **skip this read** — the file is this task's own product. The same rule applies to `tech-stack.md` and `entity-model.md`. When all three would be skipped (i.e. the task's job is to author the product documents themselves), derive product context from the briefing files under `.bot/workspace/product/briefing/` or from the task description and PRD instead.
-
-1. **Read mission (skip if in task `outputs`):**
-   ```
-   Read({ file_path: ".bot/workspace/product/mission.md" })
-   ```
-
-2. **Extract relevant portions:**
-   Don't include the full files - extract only what's relevant.
-
-**Example output:**
-```json
-{
-  "product_context": {
-    "mission_summary": "Personal productivity app for managing time and tasks",
-    "entity_definitions": "CalendarEvent: Represents a scheduled event with start/end time, title, and optional recurrence",
-    "tech_stack_relevant": ".NET 10, EF Core 10, SQLite"
-  }
-}
-```
-
-### Phase 7: Implementation Guidance
-
-Synthesize findings into **concrete, actionable guidance** that makes execution mechanical. The executor should NOT need to make design decisions or re-read pattern files.
-
-1. **Determine approach:**
-   Describe the implementation approach with specific structural details.
-
-2. **Specify concrete details (by task type):**
-
-   **For UI/Frontend tasks:**
-   - HTML/component structure with class names
-   - CSS properties for new styles (use existing variables)
-   - Function signatures with parameters
-   - Field-to-display mappings: which data goes where, in what format
-
-   **For Backend/API tasks:**
-   - Property/method signatures with types
-   - Configuration patterns to follow
-   - Endpoint structure and response shapes
-
-   **For Data/Entity tasks:**
-   - Schema changes with field types
-   - Migration approach
-   - Relationship configurations
-
-3. **Identify insertion points:**
-   Where in each file should changes go? Reference line numbers or landmarks.
-
-4. **Extract key patterns:**
-   Copy the specific pattern snippets from `patterns_from` files - don't just reference them.
-
-5. **Note risks:**
-   What could go wrong? What needs careful attention?
-
-6. **Estimate tokens:**
-   Rough estimate of tokens needed for implementation.
-
-**Example output (Backend task):**
-```json
-{
-  "implementation": {
-    "approach": "Add RecurrenceRule property to CalendarEvent. Create EF migration. Follow Task entity pattern.",
-    "key_patterns": "From TaskConfiguration.cs: `builder.Property(x => x.Status).HasConversion<string>().HasMaxLength(20);`",
-    "insertion_points": {
-      "CalendarEvent.cs": "After line 24 (existing properties)",
-      "CalendarEventConfiguration.cs": "New file, follow TaskConfiguration.cs structure"
-    },
-    "risks": ["Migration may require data backfill", "Recurrence logic is complex"],
-    "estimated_tokens": 15000
-  }
-}
-```
-
-**Example output (UI task):**
-```json
-{
-  "implementation": {
-    "approach": "Two-column modal: sidebar navigation + main content panel",
-    "structure": {
-      "layout": ".modal-sidebar-layout { display: grid; grid-template-columns: 180px 1fr; }",
-      "sections": ["overview", "details", "activity"],
-      "field_mapping": {
-        "overview": ["id", "name", "status (badge)", "priority", "created_at (compact date)"],
-        "details": ["description", "acceptance_criteria (list)"],
-        "activity": ["activity_log (timeline format)"]
-      }
-    },
-    "key_patterns": "From modal.css line 45: `.modal-wide { max-width: 900px; }`",
-    "insertion_points": {
-      "modal.css": "After .modal-wide (line 52)",
-      "tasks.js": "Replace showTaskModal() lines 52-320"
-    },
-    "risks": ["Needs responsive breakpoint below 768px"],
-    "estimated_tokens": 20000
-  }
-}
-```
-
-### Phase 8: Clarifying Questions (If Needed)
-
-If you encounter ambiguity that would affect implementation, pause for input.
-
-**When to ask:**
-- Task requirements are ambiguous
-- Multiple valid approaches exist with significant trade-offs
-- Missing information that can't be inferred
-
-**When NOT to ask:**
-- You can make a reasonable default choice
-- The question is about implementation details you can decide
-- Standard patterns obviously apply
-
-**Question Format Requirements:**
-- Provide **3-5 well-thought-out options** (never fewer than 3, never more than 5)
-- Option A should be your **recommended choice**
-- Each option must have a clear label and rationale
-- Specify if the question allows **multi_select** (user can choose multiple options)
-- Single-select is the default when one approach must be chosen
-
-**To pause for a question** (two calls — write the question under `extensions.runner.pending_question`, then flip status):
-```
-mcp__dotbot__task_update({
-  task_id: "{{TASK_ID}}",
-  extensions: {
-    runner: {
-      pending_question: {
-        question: "How should recurrence exceptions be handled?",
-        context: "When a recurring event has one instance modified or deleted, we need a strategy.",
-        multi_select: false,
-        options: [
-          { key: "A", label: "Exception dates array (recommended)", rationale: "Simple, used by most calendar systems" },
-          { key: "B", label: "Separate exception entity", rationale: "More flexible but complex" },
-          { key: "C", label: "Copy on modify (break recurrence)", rationale: "Simplest but loses recurrence relationship" },
-          { key: "D", label: "Hybrid approach", rationale: "Exception dates for deletes, separate entity for modifications" }
-        ],
-        recommendation: "A"
-      }
-    }
-  }
-})
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "needs-input" })
-```
-
-**Multi-select example:**
-```
-mcp__dotbot__task_update({
-  task_id: "{{TASK_ID}}",
-  extensions: {
-    runner: {
-      pending_question: {
-        question: "Which notification channels should be supported?",
-        context: "The task mentions notifications but doesn't specify channels.",
-        multi_select: true,
-        options: [
-          { key: "A", label: "Email notifications (recommended)", rationale: "Universal, reliable delivery" },
-          { key: "B", label: "Push notifications", rationale: "Real-time but requires app" },
-          { key: "C", label: "SMS notifications", rationale: "High visibility but costly" },
-          { key: "D", label: "In-app notifications only", rationale: "Simplest implementation" },
-          { key: "E", label: "Webhook integrations", rationale: "For external system integration" }
-        ],
-        recommendation: "A"
-      }
-    }
-  }
-})
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "needs-input" })
-```
-
-For a batch of up to four questions at once, use `extensions.runner.pending_questions: [ ...question objects... ]` (plural) instead of the singular `pending_question`. Each object in the array must use the same structured shape shown above, including `options: [{ key: "A", label: "...", rationale: "..." }, ...]`. Never put `Options: (A) ... (B) ...` inside the `question` string.
-
-Then STOP and wait. Do not continue analysis until question is answered.
-
-**After each answer is received**, apply the same decision-capture check as Phase 1.5 step 3: if the answer reveals a choice with real trade-offs and cross-task implications (architectural, business, technical, or process), create a Decision record via `decision_create` with the appropriate `type`, `related_task_ids: ["{{TASK_ID}}"]`, and `tags: ["task-derived"]`.
-
-**If the resolved question includes `attachments`**, read each attached file using its `path` field (relative to the project root, e.g. `.bot/workspace/attachments/{task_id}/{question_id}/file.pdf`). These files contain additional context the user provided with their answer — incorporate their content into your analysis.
-
-### Phase 9: Split Proposal (If Needed)
-
-If the task is too large for a single implementation session, propose splitting.
-
-**Split criteria:**
-- Effort is {{SPLIT_THRESHOLD_EFFORT}} or higher — splitting is MANDATORY, not optional
-- Multiple independent features bundled together
-- Implementation would exceed ~25,000 tokens
-
-**To propose a split** (two calls — write the proposal under `extensions.runner.split_proposal`, then flip status):
-```
-mcp__dotbot__task_update({
-  task_id: "{{TASK_ID}}",
-  extensions: {
-    runner: {
-      split_proposal: {
-        reason: "Task contains 3 independent features: entity creation, API endpoints, and UI. Each should be a separate task.",
-        sub_tasks: [
-          { name: "Create CalendarEvent entity and migration", description: "Domain model and EF configuration", effort: "M" },
-          { name: "Add CalendarEvent API endpoints", description: "CRUD operations", effort: "M" },
-          { name: "Create CalendarEvent UI components", description: "List, detail, edit views", effort: "L" }
-        ]
-      }
-    }
-  }
-})
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "needs-input" })
-```
-
-Then STOP and wait for approval before continuing.
-
-### Phase 10: Complete Analysis
-
-Once all phases are complete (and no questions/splits pending), mark the task as analysed.
-
-**Embed for the executor.** The execution phase (99-autonomous-task) is instructed to trust this package and not re-read source files unless a section is marked `TODO`. So the analysis you submit must contain everything the executor needs — not pointers to source. Specifically:
-
-- Pull short verbatim excerpts (1-3 lines per quote) from any briefing or product file the executor would otherwise re-read, and include them under `briefing_excerpts` keyed by file path.
-- Inline the 2-3 line pattern snippets from `files.patterns_from` into `implementation.key_patterns` as actual text, not as "see file X line Y".
-- For decisions, copy the `decision` and `consequences` text into the `decisions` array; do not list IDs alone.
-- If a section truly cannot be resolved during analysis, write the literal string `"TODO"` for that field — that is the only signal the executor uses to authorise re-reading source.
-
-```
-mcp__dotbot__task_update({
-  task_id: "{{TASK_ID}}",
-  extensions: {
-    analysis: {
-      entities: { ... },
-      files: { ... },
-      dependencies: { ... },
-      standards: { ... },
-      decisions: [ ... ],     // Decision constraints resolved in Phase 5 + any created during Phase 1.5/8 question resolution
-      product_context: { ... },
-      briefing_excerpts: {
-        "mission.md": "Quoted lines from mission that the executor needs",
-        "tech-stack.md": "Quoted runtime / framework constraints"
-      },
-      implementation: { ... }
-    }
-  }
-})
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "analysed" })
-```
-
----
-
-## Dotbot MCP Tools
-
-| Tool | Purpose |
-|------|---------|
-| `mcp__dotbot__task_set_status` | Transition the task (`analysing`, `analysed`, `needs-input`, `skipped`, …). Pass `reason` for `skipped`/`cancelled`. |
-| `mcp__dotbot__task_update` | Write non-status fields: the analysis package under `extensions.analysis`, and HITL state (`pending_question`/`pending_questions`/`split_proposal`) under `extensions.runner.*`. Pair with `task_set_status` to pause or complete analysis. |
-| `mcp__dotbot__plan_get` | Check for existing implementation plan |
-| `mcp__dotbot__plan_create` | Create plan if complex task |
-| `mcp__dotbot__decision_create` | Record reusable decisions from question answers |
-| `mcp__dotbot__decision_list` | List accepted decisions for context |
-| `mcp__dotbot__decision_get` | Read a specific decision |
-
----
-
-## Anti-Patterns
-
-### ❌ Implementing Instead of Analysing
-**Don't:** Write code, make edits, or create files
-**Do:** Research, discover, and document what WILL be done
-
-### ❌ Reading Everything
-**Don't:** Read entire codebases, all standards, full entity models
-**Do:** Read only what's needed for THIS task
-
-### ❌ Asking Unnecessary Questions
-**Don't:** Ask about things you can reasonably decide
-**Do:** Only ask when ambiguity significantly affects implementation
-
-### ❌ Over-Analysis
-**Don't:** Spend 30 minutes on a 15-minute task
-**Do:** Match analysis depth to task complexity
-
-### ❌ Abstract Implementation Guidance
-**Don't:** "Refactor the modal to use a sidebar layout"
-**Do:** Specify structure, class names, field mappings, insertion points
-
-### ❌ Referencing Without Extracting
-**Don't:** "Follow the pattern in TaskConfiguration.cs"
-**Do:** Copy the relevant 2-3 line snippet the executor should mimic
-
----
-
-## Success Criteria
-
-Analysis is complete when:
-
-- [ ] Task marked as analysing (Phase 1)
-- [ ] Entities identified and context summarized
-- [ ] Files categorized (to_modify, patterns_from, tests_to_update)
-- [ ] Dependencies validated (no blockers)
-- [ ] Standards mapped to task
-- [ ] Product context extracted (minimal, relevant)
-- [ ] Implementation guidance is **concrete and actionable:**
-  - [ ] Insertion points identified (line numbers or landmarks)
-  - [ ] Key pattern snippets extracted (not just referenced)
-  - [ ] Field/data mappings complete (if displaying data)
-  - [ ] Structure defined (HTML/CSS for UI, signatures for code)
-- [ ] Questions asked if truly needed (then wait)
-- [ ] Split proposed if task too large (then wait)
-- [ ] Task marked as analysed with full context
-
-**Litmus test:** Could execution proceed without re-reading pattern files or making design decisions?
-
----
-
-## Important Reminders
-
-1. **You are NOT implementing** - only researching and preparing
-2. **Be thorough but efficient** - match effort to task size
-3. **Ask questions early** - better to clarify now than fail during implementation
-4. **Package context tightly** - implementation phase should not need to explore
-5. **Note risks and gotchas** - help implementation avoid pitfalls
diff --git a/content/prompts/99-autonomous-task.md b/content/prompts/99-autonomous-task.md
deleted file mode 100644
index 7ca98bd5..00000000
--- a/content/prompts/99-autonomous-task.md
+++ /dev/null
@@ -1,279 +0,0 @@
----
-{
-  "name": "Autonomous Task Execution",
-  "description": "Template for Go Mode autonomous task implementation (with pre-flight analysis)",
-  "version": 2
-}
----
-# Autonomous Task Execution
-
-You are an autonomous AI coding agent operating in Go Mode. Your mission is to complete the assigned task using the pre-packaged analysis context.
-
-## Phase 0: Load Required Tools
-
-**Built-in tools** (`WebSearch`, `WebFetch`, `Read`, `Write`, `Edit`, `Bash`, `Glob`, `Grep`) are always available — never use ToolSearch for them.
-
-> The Bash tool runs Bash, not PowerShell. Do not use `$obj.property`, `$_.Name`, `Get-ChildItem`, or `Where-Object`. Use `jq` for JSON, `awk` or `cut` for fields, `$(command)` for substitution, `grep` and `find` for filtering. If you need PowerShell semantics, run `pwsh -Command "<script>"` explicitly.
-
-**Load dotbot tools** (single bulk call — `select:` accepts a comma-separated list):
-
-```
-ToolSearch({ query: "select:mcp__dotbot__task_get_context,mcp__dotbot__task_set_status,mcp__dotbot__task_update,mcp__dotbot__plan_get,mcp__dotbot__plan_create,mcp__dotbot__steering_heartbeat" })
-```
-
-Issue this ToolSearch call once during Phase 0. Do **NOT** broaden the query, split it across multiple calls, or try alternative search terms. If the bulk `select:` query returns no schemas on the first attempt, the dotbot MCP server is still warming up — while **still in Phase 0**, wait briefly and retry the **exact same** `select:` call. Once Phase 0 is complete, do not call ToolSearch again. If you see any `mcp__dotbot__*` tool listed as deferred in your initial tool list, that is expected — ToolSearch loads the schema on demand. Do NOT refuse on the grounds that these tools are "missing".
-
----
-
-## Session Context
-
-- **Session ID:** {{SESSION_ID}}
-- **Task ID:** {{TASK_ID}}
-- **Task Name:** {{TASK_NAME}}
-
-## Agent Context
-
-**Persona** — read this file and embody the described role throughout your implementation:
-{{APPLICABLE_AGENTS}}
-
-**Skills** — read and apply these skill guides during implementation:
-{{APPLICABLE_SKILLS}}
-
-## Working Directory
-
-You are working in the task worktree on branch `{{BRANCH_NAME}}`. Commit to
-this branch and do not push; the framework squash-merges the worktree when the
-task is complete.
-- Do NOT switch branches or modify git configuration.
-- The `.bot/` MCP tools access the central task queue.
-
-## Task Details
-
-**Category:** {{TASK_CATEGORY}}
-**Priority:** {{TASK_PRIORITY}}
-
-### Description
-{{TASK_DESCRIPTION}}
-
-### Acceptance Criteria
-{{ACCEPTANCE_CRITERIA}}
-
-### Implementation Steps
-{{TASK_STEPS}}
-
-### User Decisions
-{{QUESTIONS_RESOLVED}}
-
-### Reviewer Feedback
-{{REVIEWER_FEEDBACK}}
-
----
-
-## Implementation Protocol
-
-### Phase 1: Quick Start
-
-1. **Establish clean baseline:**
-   ```bash
-   pwsh -ExecutionPolicy Bypass -File ".bot/hooks/scripts/commit-bot-state.ps1"
-   ```
-
-2. **Mark task in-progress:**
-   ```
-   mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "in-progress" })
-   ```
-
-3. **Get pre-flight analysis context:**
-   ```
-   mcp__dotbot__task_get_context({ task_id: "{{TASK_ID}}" })
-   ```
-   
-   If `has_analysis: true`, use the packaged context:
-   - **entities**: Primary and related domain entities with context summary
-   - **files.to_modify**: Files that need changes
-   - **files.patterns_from**: Reference files for patterns (don't modify)
-   - **files.tests_to_update**: Test files to update
-   - **standards.applicable**: Standards to follow
-   - **decisions**: Architectural decisions constraining this task — treat as non-negotiable. Do not implement approaches explicitly rejected in a decision's `alternatives_considered`.
-   - **implementation.approach**: Recommended implementation approach
-   - **implementation.key_patterns**: Specific patterns to follow
-   - **implementation.risks**: Known risks to watch for
-   - **product_context** and any `briefing_excerpts`: pre-extracted quotes from `mission.md`, `tech-stack.md`, `entity-model.md`, and other briefing files
-   
-   **Trust this package as authoritative.** It was prepared by a dedicated pre-flight pass with full briefing access. Do NOT re-read `mission.md`, `tech-stack.md`, `entity-model.md`, briefing files, or files in `files.patterns_from` if the analysis already extracted what you need. Re-read source only when (a) you are about to write to a `files.to_modify` entry, (b) the analysis explicitly marks a section `TODO`, or (c) a specific symbol or snippet is referenced in the analysis but not extracted. Re-reading what is already packaged wastes turns and tokens for no signal.
-   
-   If `has_analysis: false`, fall back to exploration (see Legacy Mode below).
-
-4. **Check for implementation plan:**
-   ```
-   mcp__dotbot__plan_get({ task_id: "{{TASK_ID}}" })
-   ```
-   If plan exists, follow documented approach.
-
-### Phase 2: Implementation
-
-1. **Read files from analysis:**
-   - Start with `files.to_modify` - these are the files you need to change
-   - Reference `files.patterns_from` for implementation patterns
-   - Follow `implementation.key_patterns` guidance
-
-2. **Follow standards:**
-   - Read standards listed in `standards.applicable`
-   - Apply patterns from `standards.relevant_sections`
-   - Pre-specified standards from task configuration: {{APPLICABLE_STANDARDS}}
-
-3. **Code quality:**
-   - Follow TDD where appropriate
-   - Match existing codebase conventions
-   - Include error handling and logging
-
-4. **Make incremental commits:**
-   - Commit after each logical unit of work
-   - Use conventional commit messages
-   - Include task ID: `[task:XXXXXXXX]` (first 8 chars of {{TASK_ID}})
-   - Include workspace tag: `[bot:XXXXXXXX]` (first 8 chars of {{INSTANCE_ID}})
-   - **Commit ALL modified files** — including any files modified as a side-effect of running commands during the task. Package managers, build tools, code generators, and formatters all produce files you must commit. Common examples by ecosystem:
-     - **Node.js / Bun**: `package.json`, package lockfiles, `yarn.lock`, `bun.lockb`
-     - **Python**: `Pipfile.lock`, `poetry.lock`, `uv.lock`, `requirements.txt`
-     - **.NET / NuGet**: `*.csproj`, `packages.lock.json`, `NuGet.lock.json`, `global.json`
-     - **Go**: `go.mod`, `go.sum`
-     - **Ruby**: `Gemfile.lock`
-     - **Rust**: `Cargo.lock`
-     - **Java / Kotlin / Scala**: `pom.xml`, `build.gradle`, `gradle.lockfile`, `gradle/wrapper/gradle-wrapper.properties`
-     - **PHP**: `composer.lock`
-     - **Any stack**: generated code, migration files, auto-formatted source files, scaffolded configuration
-
-     The `01-git-clean.ps1` verification will fail if any non-`.bot/` file is left uncommitted when you transition the task to `done`.
-   - Example:
-     ```
-     Add CalendarEvent entity with EF Core configuration
-
-     [task:7b012fb8]
-     [bot:1a2b3c4d]
-     Co-Authored-By: dotbot <noreply@dotbot.local>
-     ```
-
-### Phase 3: Verification
-
-1. **Run tests** (if applicable)
-
-2. **Run verification scripts:**
-   ```bash
-   pwsh -ExecutionPolicy Bypass -File ".bot/hooks/verify/00-privacy-scan.ps1" 2>&1
-   pwsh -ExecutionPolicy Bypass -File ".bot/hooks/verify/01-git-clean.ps1" 2>&1
-   ```
-
-   Before running `01-git-clean.ps1`, confirm your working tree is fully clean:
-   ```bash
-   git status --porcelain
-   ```
-   There must be **zero** uncommitted non-`.bot/` files. If you ran any package manager, build tool, or code generator (`npm install`, `pip install`, `go get`, `dotnet restore`, `bundle install`, `cargo build`, `composer install`, etc.), make sure all resulting manifest and lock file changes are staged and committed before this check.
-
-3. **Handle failures:**
-   - Privacy scan: Fix ALL violations (use repo-relative paths, never absolute paths)
-   - Git clean: Stage and commit ALL modified non-`.bot/` files. Pay particular attention to package manager side-effects: lock files, updated manifests, generated code, and auto-formatted files — these vary by tech stack but `git status --porcelain` will reveal them all.
-   - Build/format: Always fix before proceeding
-
-### Phase 4: Completion
-
-1. Verify all acceptance criteria are met
-2. All verification scripts pass
-3. Mark complete:
-
-   **If the task has `extensions.review.required === true`**: do NOT call `task_set_status(done)`. Park for human review instead so a human can approve or reject the work:
-   ```
-   mcp__dotbot__task_mark_needs_review({ task_id: "{{TASK_ID}}", reason: "<one-line summary of what was done>" })
-   ```
-   The task moves to `needs-review`. A reviewer then calls `task_submit_review` from the UI or MCP. On approval the runtime runs verification, merges the worktree, and transitions to `done`. On rejection the worktree is discarded and the task returns to `todo` with reviewer feedback in `extensions.review.feedback[]`.
-
-   **Otherwise** (normal flow):
-   ```
-   mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "done" })
-   ```
-
----
-
-## Legacy Mode (No Pre-flight Analysis)
-
-If `task_get_context` returns `has_analysis: false`, use targeted exploration:
-
-1. **Search for relevant code:**
-   - Use `grep` for exact symbols/function names
-   - Use `codebase_semantic_search` for concepts
-   - Read 1-2 key files to understand patterns
-
-2. **Read context files only when needed:**
-   - `.bot/workspace/product/entity-model.md` - domain knowledge
-   - Agent persona: {{APPLICABLE_AGENTS}}
-
-3. **Avoid over-reading:**
-   - DON'T read entire directories
-   - DON'T read the same file twice
-   - DON'T use both grep and glob for the same search
-
----
-
-## MCP Tools Reference
-
-| Tool | Purpose |
-|------|---------|
-| `task_get_context` | Get pre-flight analysis (call first) |
-| `task_set_status` | Transition a task to a new status (`in-progress`, `done`, `skipped`, `needs-input`, `cancelled`, etc.). For `skipped`/`cancelled`, pass `reason`. |
-| `task_update` | Set non-status fields (e.g. `extensions.runner.pending_questions` or `extensions.runner.split_proposal`). Pair with `task_set_status` when pausing for human input. |
-| `plan_get` | Get linked implementation plan |
-| `plan_create` | Create plan for complex tasks |
-| `steering_heartbeat` | Post status, check for operator whispers |
-
-> Pausing for input is a two-step pattern: first `task_update({ task_id, extensions: { runner: { pending_questions: [...] } } })` to record the batch of questions (up to 4), then `task_set_status({ task_id, status: "needs-input" })`. The task resumes only after every question is answered. Use this (not `AskUserQuestion`) when the task requires user decisions before proceeding.
->
-> Every pending question must have structured `options`; never write choices inline in `question` text. Valid shape:
-> ```javascript
-> {
->   id: "q1",
->   question: "Single sentence question ending with?",
->   context: "Short explanation of why this blocks progress.",
->   options: [
->     { key: "A", label: "Recommended path", rationale: "Why this is the default" },
->     { key: "B", label: "Alternative path", rationale: "When this is better" },
->     { key: "C", label: "Defer or skip", rationale: "How the task proceeds if deferred" }
->   ],
->   recommendation: "A"
-> }
-> ```
-
-**Context7 MCP** (documentation lookup):
-- `resolve-library-id` → `get-library-docs` for API documentation
-
-**Playwright MCP** (UI testing):
-- `browser_navigate`, `browser_screenshot`, `browser_click`, `browser_type`
-
----
-
-## Error Recovery
-
-- **Build fails**: Check error, search codebase for patterns, use Context7 for docs
-- **Tests fail**: Analyze message, fix root cause, ensure all pass
-- **Verification fails**: Address systematically, re-run until pass
-- **Stuck**: Skip with `task_set_status({ task_id, status: "skipped", reason: "..." })` if unrecoverable
-
----
-
-## Success Criteria
-
-- [ ] All acceptance criteria met
-- [ ] Code follows applicable standards
-- [ ] All verification scripts pass
-- [ ] Tests pass (if applicable)
-- [ ] Changes committed with task ID
-- [ ] Task marked complete
-
----
-
-## Important Reminders
-
-1. **Use pre-flight context** - don't re-explore what's already analysed
-2. **Stay focused** - don't scope creep
-3. **Follow existing patterns** - match codebase conventions
-4. **Verify before completing** - run all scripts
-5. **Never emit secrets or local paths** - use relative paths only
-6. **Check steering channel** - call `steering_heartbeat` between major steps
diff --git a/content/workflows/start-from-jira/prompts/98-analyse-task.md b/content/workflows/start-from-jira/prompts/98-analyse-task.md
deleted file mode 100644
index d9df8227..00000000
--- a/content/workflows/start-from-jira/prompts/98-analyse-task.md
+++ /dev/null
@@ -1,328 +0,0 @@
----
-{
-  "name": "Pre-flight Task Analysis (Multi-Repo)",
-  "description": "Research-aware override of 98-Analyse — dispatches research methodology for research-category tasks",
-  "version": 1
-}
----
-# Pre-flight Task Analysis (Multi-Repo Override)
-
-You are an autonomous AI coding agent performing **pre-flight analysis** of a task. Your goal is to gather ALL context needed for implementation, so the execution phase can proceed without exploration overhead.
-
-## Phase 0: Load Required Tools
-
-**Built-in tools** (`WebSearch`, `WebFetch`, `Read`, `Write`, `Edit`, `Bash`, `Glob`, `Grep`) are always available — never use ToolSearch for them.
-
-**Step 1 — Load core dotbot tools** (always, all in parallel):
-
-```
-ToolSearch({ query: "select:mcp__dotbot__task_set_status" })
-ToolSearch({ query: "select:mcp__dotbot__task_update" })
-ToolSearch({ query: "select:mcp__dotbot__research_status" })
-ToolSearch({ query: "select:mcp__dotbot__plan_get" })
-ToolSearch({ query: "select:mcp__dotbot__plan_create" })
-```
-
-**Step 2 — Load research-specific tools** (in the same parallel batch, based on `research_prompt`):
-
-| research_prompt | Additional ToolSearch calls |
-|---|---|
-| `repos.md` | `select:mcp__sourcebot__search_code`, `select:mcp__sourcebot__list_repos`, `select:mcp__sourcebot__read_file`, `select:mcp__sourcebot__list_tree`, `select:mcp__sourcebot__ask_codebase` |
-| `repo-deep-dive.md` | All sourcebot tools above + `select:mcp__dotbot__repo_clone`, `select:mcp__dotbot__repo_list` |
-| `atlassian.md` | `select:mcp__dotbot__atlassian_download`, `select:mcp__atlassian__getJiraIssue`, `select:mcp__atlassian__searchJiraIssuesUsingJql`, `select:mcp__atlassian__searchConfluenceUsingCql`, `select:mcp__atlassian__getConfluencePage` |
-| `public.md` | **None** — internet research uses only built-in WebSearch and WebFetch |
-| _(not research)_ | None |
-
-Issue all ToolSearch calls from Steps 1 and 2 in a **single parallel batch**. Do not call ToolSearch again after Phase 0.
-
----
-
-## Session Context
-
-- **Session ID:** {{SESSION_ID}}
-- **Task ID:** {{TASK_ID}}
-- **Task Name:** {{TASK_NAME}}
-
-## Working Directory
-
-You are working on the **main branch** of the repository.
-- Do NOT modify code files — you are preparing, not implementing
-- The .bot/ MCP tools access the central task queue
-
-## Task Details
-
-**Category:** {{TASK_CATEGORY}}
-**Priority:** {{TASK_PRIORITY}}
-**Effort:** {{TASK_EFFORT}}
-**Needs Interview:** {{NEEDS_INTERVIEW}}
-
-### Description
-{{TASK_DESCRIPTION}}
-
-### Acceptance Criteria
-{{ACCEPTANCE_CRITERIA}}
-
-### Implementation Steps (if any)
-{{TASK_STEPS}}
-
----
-
-## Research Category Dispatch
-
-**This is the key override.** Before running the standard analysis protocol, check if this task is a research task.
-
-### Check: Is this a research task?
-
-```
-IF task.category == "research" AND task has a "research_prompt" field:
-    → Use RESEARCH ANALYSIS MODE (below)
-ELSE:
-    → Use STANDARD ANALYSIS MODE (Phase 1-10 from default 98-analyse-task)
-```
-
----
-
-## RESEARCH ANALYSIS MODE
-
-When the task category is `research` and the task has a `research_prompt` field, the analysis phase operates differently. Instead of the standard 10-phase protocol (entity detection, file discovery, etc.), the analysis loads a research methodology prompt and prepares the execution phase for research output.
-
-### Research Phase 1: Mark Task In Analysis
-
-```
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "analysing" })
-```
-
-### Research Phase 2: Load Initiative Context
-
-Read the initiative document for all context needed by the research methodology:
-
-```
-Read({ file_path: ".bot/workspace/product/briefing/jira-context.md" })
-```
-
-Extract from `jira-context.md`:
-- **Jira Key** (e.g., `PROJ-1234`)
-- **Initiative Name** (e.g., `Payment Gateway Upgrade`)
-- **Business Objective**
-- **Parent Programme**
-- **Reference Implementation** (if identified)
-- **Organisation Settings** (ADO org URL, Atlassian cloud ID, etc.)
-- **Team members**
-
-These values will be substituted into the research methodology prompt.
-
-> **Path reference** — Initiative context is in `briefing/` but research outputs are one level up:
-> - Initiative context: `.bot/workspace/product/briefing/jira-context.md`
-> - Research outputs: `.bot/workspace/product/research-documents.md`, `research-internet.md`, `research-repos.md`
-> - Deep dive outputs: `.bot/workspace/product/briefing/repos/{RepoName}.md`
-
-### Research Phase 3: Load Research Methodology
-
-Load the research prompt specified in the task's `research_prompt` field:
-
-```
-Read({ file_path: ".bot/content/workflows/start-from-jira/research/{{TASK.research_prompt}}" })
-```
-
-The research prompt is a **methodology document** — it defines:
-- What to research
-- How to structure the investigation
-- What output sections are required
-- Quality standards and behavioral instructions
-
-### Research Phase 4: Load Prior Research (if applicable)
-
-If this task has dependencies, the dependent research outputs should already exist. Load them for context:
-
-- `.bot/workspace/product/research-documents.md` — from Atlassian research
-- `.bot/workspace/product/research-internet.md` — from public research
-- `.bot/workspace/product/research-repos.md` — from repo scan
-
-Only load what exists and is relevant to this task's methodology.
-
-### Research Phase 5: Determine Working Directory
-
-Check if the task has a `working_dir` field:
-
-- If `working_dir` is set (e.g., `repos/OrderService`): the execution phase should operate in that directory relative to the project root
-- If not set: the execution phase operates in the project root as normal
-
-For deep dive tasks with `external_repo` field:
-1. Check if the repo is already cloned at `repos/{RepoName}/`
-2. If not, note that the execution phase should call `repo_clone` first
-
-### Research Phase 6: Prepare Execution Context
-
-Package the analysis for the execution phase (99-autonomous-task) — write the package under `extensions.analysis`, then flip the status to `analysed`:
-
-```
-mcp__dotbot__task_update({
-  task_id: "{{TASK_ID}}",
-  extensions: {
-    analysis: {
-      mode: "research",
-      research_prompt: "{{TASK.research_prompt}}",
-      initiative: {
-        jira_key: "<from jira-context.md>",
-        name: "<from jira-context.md>",
-        business_objective: "<from jira-context.md>",
-        reference_implementation: "<from jira-context.md>",
-        ado_org_url: "<from jira-context.md or .env.local>"
-      },
-      prior_research: [
-        "<full relative paths, e.g. .bot/workspace/product/research-documents.md>"
-      ],
-      working_dir: "<from task, or null>",
-      external_repo: "<from task, or null>",
-      output_path: "<expected output file path from methodology>",
-      methodology_summary: "<brief summary of what the research prompt instructs>"
-    }
-  }
-})
-mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "analysed" })
-```
-
-### Research Phase 7: User Interview (If Needed)
-
-If `needs_interview` is `true`, ask clarifying questions about the research scope before completing analysis. Use the same `task_update` + `task_set_status({ status: "needs-input" })` pause pattern as the default 98 (write the question under `extensions.runner.pending_question`). Every question must include structured `options` with A-E keys and labels; never inline `Options: (A) ...` inside the `question` text.
-
----
-
-## STANDARD ANALYSIS MODE
-
-When the task is NOT a research task, use the standard 10-phase analysis protocol. The only additions to the default behavior are:
-
-### Addition 1: Initiative Context (prepend to Phase 6)
-
-Before extracting product context, also read:
-```
-Read({ file_path: ".bot/workspace/product/briefing/jira-context.md" })
-```
-
-Include the initiative's Jira key, business objective, and reference implementation in the `product_context` section of the analysis output.
-
-### Addition 2: Working Directory (add to Phase 4)
-
-If the task has a `working_dir` field, include it in the analysis output so the execution phase knows to operate in a different directory.
-
-### Addition 3: Research Outputs as Context
-
-If research outputs exist in `.bot/workspace/product/briefing/`, reference relevant ones in the product context. Don't read them all — only those that are relevant to the specific task being analysed.
-
-### Addition 4: Environment Pre-flight (before Phase 3)
-
-Before file discovery, verify the build environment in the task's `working_dir` (or project root). This applies to implementation tasks only (not research tasks).
-
-#### 4a. Git working tree state
-
-Run `git status --porcelain` in the working directory. Document any unexpected changes in `implementation.pre_existing_changes`. On Windows, check `git config core.longpaths` — if not `true`, note as a risk for repos with deep paths.
-
-#### 4b. Detect tech stack and invoke pre-flight skill
-
-Detect the project's build system by checking for marker files:
-
-| Marker file | Tech stack |
-|-------------|-----------|
-| `*.sln` or `*.csproj` | dotnet |
-| `package.json` | node |
-| `pom.xml` or `build.gradle` | java |
-| `requirements.txt` or `pyproject.toml` | python |
-
-Then check if a matching pre-flight skill exists:
-
-```
-Glob({ pattern: ".bot/content/skills/tech-preflight-{detected-tech}/SKILL.md" })
-```
-
-If found, read and follow the skill's instructions. The skill will handle:
-- SDK/runtime compatibility checks
-- Project dependency graph mapping
-- Baseline build snapshot
-- Architecture constraint identification
-
-If no matching skill exists, perform a generic baseline:
-- Attempt to run the project's standard build command (if identifiable)
-- Record pass/fail and any error output
-
-#### 4c. Include findings in analysis output
-
-Add an `environment` key alongside the rest of the package under `extensions.analysis` (issued via `task_update` before the `task_set_status` flip to `analysed`):
-```json
-{
-  "environment": {
-    "tech_stack": "dotnet",
-    "pre_existing_changes": "...",
-    "git_longpaths": true,
-    "sdk_gaps": [],
-    "dependency_graph": {},
-    "baseline_build": { "status": "pass", "error_count": 0, "warning_count": 42, "pre_existing_errors": [] }
-  }
-}
-```
-
-### Default Phases (1-10)
-
-All other phases proceed exactly as specified in the default 98-analyse-task workflow:
-1. Mark task analysing
-2. User interview (if needed)
-3. Entity detection
-4. File discovery
-5. Dependency validation
-6. Standards mapping
-7. Product context extraction (+ initiative context)
-8. Implementation guidance
-9. Clarifying questions (if needed)
-10. Split proposal (if needed) → Complete analysis
-
----
-
-## Dotbot MCP Tools
-
-| Tool | Purpose |
-|------|---------|
-| `mcp__dotbot__task_set_status` | Transition the task (`analysing`, `analysed`, `needs-input`, `skipped`, …). Pass `reason` for `skipped`/`cancelled`. |
-| `mcp__dotbot__task_update` | Write non-status fields: the analysis package under `extensions.analysis`, and HITL state (`pending_question`/`pending_questions`/`split_proposal`) under `extensions.runner.*`. Pair with `task_set_status` to pause or complete analysis. |
-| `mcp__dotbot__plan_get` | Check for existing implementation plan |
-| `mcp__dotbot__plan_create` | Create plan if complex task |
-
----
-
-## Anti-Patterns
-
-### Do Not Re-read the Full Research Prompt at Execution Time
-The analysis phase packages everything the executor needs. The research prompt is a methodology guide for analysis, not an execution script.
-
-### Do Not Skip Initiative Context for Research Tasks
-Every research task needs initiative context — the Jira key, business objective, and reference implementation drive the research methodology.
-
-### Do Not Over-Package
-For research tasks, the executor needs: the methodology summary, initiative context, prior research references, and output path. It does NOT need entity models, file inventories, or insertion points.
-
----
-
-## Success Criteria
-
-### For Research Tasks:
-- [ ] Task marked as analysing
-- [ ] Initiative context loaded and extracted
-- [ ] Research methodology loaded and summarized
-- [ ] Prior research loaded (if dependencies met)
-- [ ] Working directory and external repo noted
-- [ ] Output path identified
-- [ ] Task marked as analysed with research-mode context
-
-### For Standard Tasks:
-- [ ] All default 98 success criteria met
-- [ ] Initiative context included in product context
-- [ ] Working directory noted (if applicable)
-- [ ] Relevant research outputs referenced
-
----
-
-## Important Reminders
-
-1. **You are NOT implementing** — only researching and preparing
-2. **Research vs Standard** — check the category first, then follow the right path
-3. **Initiative context is always relevant** — read jira-context.md for both modes
-4. **Package context tightly** — the execution phase should not need to re-explore
-5. **Note risks and gotchas** — help implementation avoid pitfalls
diff --git a/content/workflows/start-from-jira/prompts/99-autonomous-task.md b/content/workflows/start-from-jira/prompts/99-autonomous-task.md
deleted file mode 100644
index 53cf056c..00000000
--- a/content/workflows/start-from-jira/prompts/99-autonomous-task.md
+++ /dev/null
@@ -1,312 +0,0 @@
----
-{
-  "name": "Autonomous Task Execution (Multi-Repo)",
-  "description": "Research-aware override of 99-autonomous — handles research output and external repo execution",
-  "version": 1
-}
----
-# Autonomous Task Execution (Multi-Repo Override)
-
-You are an autonomous AI coding agent operating in Go Mode. Your mission is to complete the assigned task using the pre-packaged analysis context.
-
-## Phase 0: Load Required Tools
-
-**Built-in tools** (`WebSearch`, `WebFetch`, `Read`, `Write`, `Edit`, `Bash`, `Glob`, `Grep`) are always available — never use ToolSearch for them.
-
-**Step 1 — Load core dotbot tools** (always, all in parallel):
-
-```
-ToolSearch({ query: "select:mcp__dotbot__task_get_context" })
-ToolSearch({ query: "select:mcp__dotbot__task_set_status" })
-ToolSearch({ query: "select:mcp__dotbot__task_update" })
-ToolSearch({ query: "select:mcp__dotbot__steering_heartbeat" })
-ToolSearch({ query: "select:mcp__dotbot__research_status" })
-ToolSearch({ query: "select:mcp__dotbot__plan_get" })
-```
-
-**Step 2 — Load task-type-specific tools** (same parallel batch, based on analysis `research_prompt`):
-
-| research_prompt | Additional ToolSearch calls |
-|---|---|
-| `repos.md` | `select:mcp__sourcebot__search_code`, `select:mcp__sourcebot__list_repos`, `select:mcp__sourcebot__read_file`, `select:mcp__sourcebot__list_tree`, `select:mcp__sourcebot__ask_codebase` |
-| `repo-deep-dive.md` | All sourcebot tools above + `select:mcp__dotbot__repo_clone`, `select:mcp__dotbot__repo_list` |
-| `atlassian.md` | `select:mcp__dotbot__atlassian_download`, `select:mcp__atlassian__getJiraIssue`, `select:mcp__atlassian__searchJiraIssuesUsingJql`, `select:mcp__atlassian__searchConfluenceUsingCql`, `select:mcp__atlassian__getConfluencePage` |
-| `public.md` | **None** — internet research uses only built-in WebSearch and WebFetch |
-| _(standard task)_ | `select:mcp__context7__resolve-library-id`, `select:mcp__context7__get-library-docs` |
-
-Issue all ToolSearch calls from Steps 1 and 2 in a **single parallel batch**. Do not call ToolSearch again after Phase 0.
-
----
-
-## Session Context
-
-- **Session ID:** {{SESSION_ID}}
-- **Task ID:** {{TASK_ID}}
-- **Task Name:** {{TASK_NAME}}
-
-## Working Directory
-
-You are working in the task worktree on branch `{{BRANCH_NAME}}`. Commit to
-this branch and do not push; the framework squash-merges the worktree when the
-task is complete.
-- Do NOT switch branches or modify git configuration.
-- The `.bot/` MCP tools access the central task queue.
-
-## Task Details
-
-**Category:** {{TASK_CATEGORY}}
-**Priority:** {{TASK_PRIORITY}}
-
-### Description
-{{TASK_DESCRIPTION}}
-
-### Acceptance Criteria
-{{ACCEPTANCE_CRITERIA}}
-
-### Implementation Steps
-{{TASK_STEPS}}
-
-### User Decisions
-{{QUESTIONS_RESOLVED}}
-
-### Reviewer Feedback
-{{REVIEWER_FEEDBACK}}
-
----
-
-## Execution Mode Dispatch
-
-Check the pre-packaged analysis to determine execution mode:
-
-```
-mcp__dotbot__task_get_context({ task_id: "{{TASK_ID}}" })
-```
-
-If `analysis.mode == "research"`:
-    → Use RESEARCH EXECUTION MODE (below)
-Else:
-    → Use STANDARD EXECUTION MODE (default 99 protocol)
-
----
-
-## RESEARCH EXECUTION MODE
-
-When the analysis mode is `research`, you are executing a research task — gathering information, analysing sources, and producing a structured markdown report. You are NOT writing application code.
-
-### Research Exec Phase 1: Setup
-
-1. **Establish clean baseline:**
-   ```bash
-   pwsh -ExecutionPolicy Bypass -File ".bot/hooks/scripts/commit-bot-state.ps1"
-   ```
-
-2. **Mark task in-progress:**
-   ```
-   mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "in-progress" })
-   ```
-
-3. **Load analysis context:**
-   ```
-   mcp__dotbot__task_get_context({ task_id: "{{TASK_ID}}" })
-   ```
-
-   Extract from analysis:
-   - `research_prompt` — which methodology to follow
-   - `initiative` — Jira key, name, business objective, reference implementation
-   - `prior_research` — list of existing research files to reference
-   - `working_dir` — where to operate (if external repo)
-   - `external_repo` — repo to clone (if deep dive)
-   - `output_path` — where to write the research output
-
-> **Path reference** — do not confuse `briefing/` with `product/`:
-> - Initiative context: `.bot/workspace/product/briefing/jira-context.md`
-> - Research outputs: `.bot/workspace/product/research-documents.md`, `research-internet.md`, `research-repos.md`
-> - Deep dive outputs: `.bot/workspace/product/briefing/repos/{RepoName}.md`
-
-### Research Exec Phase 2: Prepare Environment
-
-1. **Read the research methodology:**
-   ```
-   Read({ file_path: ".bot/content/workflows/start-from-jira/research/{analysis.research_prompt}" })
-   ```
-
-2. **Initiative context** is already loaded from the analysis package above (Phase 1, step 3).
-   Only re-read `jira-context.md` if the analysis context does not include `initiative` details:
-   ```
-   Read({ file_path: ".bot/workspace/product/briefing/jira-context.md" })
-   ```
-
-3. **Read prior research** (from `analysis.prior_research`):
-   Load each file listed — these provide context for this research task.
-   Skip files already summarized in the analysis context.
-
-4. **Clone external repo** (if deep dive task with `external_repo`):
-   ```
-   mcp__dotbot__repo_clone({
-     project: "{analysis.external_repo.project}",
-     repo: "{analysis.external_repo.repo}"
-   })
-   ```
-   This clones the repo to `repos/{RepoName}/` and creates the initiative branch.
-
-5. **Switch working directory** (if `working_dir` is set):
-   Navigate to the working directory for analysis. For deep dive tasks, this is the cloned repo.
-
-### Research Exec Phase 3: Execute Research
-
-Follow the research methodology prompt as your primary guide. The methodology defines:
-- What sources to investigate
-- What evidence to gather
-- How to structure the analysis
-- What output sections are required
-
-**Key principles:**
-- **Evidence-based:** Every claim must cite a source (file path, ticket key, page title, URL)
-- **No assumptions:** If information is missing, state "No evidence found"
-- **Structured output:** Follow the methodology's output structure exactly
-- **Initiative-aware:** Substitute initiative context where the methodology uses placeholders
-
-**Variable substitution:** Replace methodology placeholders with initiative context:
-- References to the Jira key → use the actual key from `jira-context.md`
-- References to the initiative name → use the actual name from `jira-context.md`
-- References to the business objective → use from `jira-context.md`
-- References to the reference implementation → use from `jira-context.md`
-- References to the ADO org URL → use from `jira-context.md` or `.env.local`
-
-### Research Exec Phase 4: Write Output
-
-1. **Write the research report** to the path specified in `analysis.output_path`:
-   - For Atlassian research: `.bot/workspace/product/research-documents.md`
-   - For public research: `.bot/workspace/product/research-internet.md`
-   - For repo scan: `.bot/workspace/product/research-repos.md`
-   - For deep dives: `.bot/workspace/product/briefing/repos/{RepoName}.md`
-
-2. **Verify output quality** against the research-output standard:
-   ```
-   Read({ file_path: ".bot/content/workflows/start-from-jira/standards/global/research-output.md" })
-   ```
-   Check: completeness, evidence citations, no assumptions, correct structure.
-
-3. **For deep dive tasks — set up per-repo workspace:**
-   Create the per-repo dotbot workspace structure:
-   ```
-   repos/{RepoName}/.bot/workspace/product/
-   repos/{RepoName}/.bot/workspace/tasks/
-   ```
-
-### Research Exec Phase 5: Commit and Complete
-
-1. **Commit the research output:**
-   Only stage files you created or modified. Never stage entire directories — other files may contain paths that fail the privacy scan.
-   ```
-   git add {analysis.output_path}
-   git commit -m "Research: {task_name}
-
-   [task:{{TASK_ID_SHORT}}]
-   [bot:{{INSTANCE_ID_SHORT}}]
-   Co-Authored-By: dotbot <noreply@dotbot.local>"
-   ```
-
-2. **Run verification scripts:**
-   ```bash
-   pwsh -ExecutionPolicy Bypass -File ".bot/hooks/verify/00-privacy-scan.ps1" 2>&1
-   ```
-
-3. **Mark task complete:**
-   ```
-   mcp__dotbot__task_set_status({ task_id: "{{TASK_ID}}", status: "done" })
-   ```
-
----
-
-## STANDARD EXECUTION MODE
-
-When the analysis mode is NOT `research`, use the standard 99-autonomous-task protocol with these additions:
-
-### Addition 1: Working Directory
-
-If `analysis.working_dir` is set, operate in that directory instead of the project root. This is used for tasks that modify cloned external repos.
-
-### Addition 2: External Repo Branch
-
-For tasks operating on external repos, commits go to the `initiative/{JIRA_KEY}` branch (already created by `repo_clone`). Do NOT create a new worktree — use the existing cloned repo directory.
-
-### Addition 3: Briefing Context
-
-Before implementing, check if relevant research exists in `.bot/workspace/product/briefing/`. Use it as additional context — don't re-research what's already been gathered.
-
-### Default Protocol (Phases 1-4)
-
-All other phases proceed exactly as specified in the default 99-autonomous-task workflow:
-1. Quick Start (baseline, mark in-progress, get context, check plan)
-2. Implementation (read files, follow standards, code quality, incremental commits)
-3. Verification (tests, verification scripts, handle failures)
-4. Completion (acceptance criteria met, mark complete)
-
----
-
-## MCP Tools Reference
-
-| Tool | Purpose |
-|------|---------|
-| `task_get_context` | Get pre-flight analysis (call first) |
-| `task_set_status` | Transition the task (`in-progress`, `done`, `skipped`, …). Pass `reason` for `skipped`/`cancelled`. |
-| `task_update` | Write non-status fields under `extensions.runner.*` when pausing or recording results. |
-| `plan_get` | Get linked implementation plan |
-| `plan_create` | Create plan for complex tasks |
-| `steering_heartbeat` | Post status, check for operator whispers |
-| `repo_clone` | Clone external repo (deep dive tasks) |
-| `repo_list` | List cloned repos and status |
-| `research_status` | Check research artifact completeness |
-
-**Context7 MCP** (documentation lookup):
-- `resolve-library-id` → `get-library-docs` for API documentation
-
-**Atlassian MCP** (for research tasks):
-- `mcp__atlassian__getJiraIssue` — read Jira ticket details
-- `mcp__atlassian__searchJiraIssuesUsingJql` — search Jira
-- `mcp__atlassian__searchConfluenceUsingCql` — search Confluence
-- `mcp__atlassian__getConfluencePage` — read Confluence page content
-
----
-
-## Error Recovery
-
-- **Research fails**: Document what was found and what couldn't be accessed. Mark `<!-- INCOMPLETE: reason -->` in the output.
-- **Repo clone fails**: Check `.env.local` for PAT, verify network access. Skip repo if permanently inaccessible.
-- **Build fails**: Check error, search codebase for patterns, use Context7 for docs
-- **Tests fail**: Analyze message, fix root cause, ensure all pass
-- **Verification fails**: Address systematically, re-run until pass
-- **Stuck**: Skip with `task_set_status({ task_id, status: "skipped", reason: "..." })` if unrecoverable
-
----
-
-## Success Criteria
-
-### For Research Tasks:
-- [ ] Research output written to correct path
-- [ ] Output follows methodology structure
-- [ ] All claims cite evidence
-- [ ] No placeholder text remaining
-- [ ] Changes committed with task ID
-- [ ] Task marked complete
-
-### For Standard Tasks:
-- [ ] All acceptance criteria met
-- [ ] Code follows applicable standards
-- [ ] All verification scripts pass
-- [ ] Tests pass (if applicable)
-- [ ] Changes committed with task ID
-- [ ] Task marked complete
-
----
-
-## Important Reminders
-
-1. **Check analysis mode first** — research vs standard changes everything
-2. **Use pre-flight context** — don't re-explore what's already analysed
-3. **Stay focused** — don't scope creep
-4. **Follow existing patterns** — match codebase conventions
-5. **Verify before completing** — run all scripts
-6. **Never emit secrets or local paths** — use relative paths only
-7. **Check steering channel** — call `steering_heartbeat` between major steps
diff --git a/content/workflows/start-from-prompt/prompts/01-plan-product.md b/content/workflows/start-from-prompt/prompts/01-plan-product.md
index f31cb043..f81eaf87 100644
--- a/content/workflows/start-from-prompt/prompts/01-plan-product.md
+++ b/content/workflows/start-from-prompt/prompts/01-plan-product.md
@@ -226,7 +226,7 @@ the decision records created by Phase 1b.]
 
 ### Phase 0: Load Tools
 
-Load dotbot MCP tools in a single ToolSearch call using the comma-separated `select:` form. Same pattern as `content/prompts/98-analyse-task.md`.
+Load dotbot MCP tools in a single ToolSearch call using the comma-separated `select:` form. Same pattern as `content/prompts/100-single-session-task.md`.
 
 ```
 ToolSearch({ query: "select:mcp__dotbot__task_get_context,mcp__dotbot__task_set_status,mcp__dotbot__task_update,mcp__dotbot__decision_create,mcp__dotbot__decision_list" })
@@ -297,7 +297,14 @@ Always include a `Defer to later release` option when deferral is a coherent cho
 
 ### Phase 4: Record Decisions
 
-For every ambiguity now resolved (agent-decidable or user-answered), call `decision_create`. Skip creation only when Phase 1's `decision_list` already returned an accepted decision for the same planning item: require the same `title` and at least one scope match, either overlapping workflow tags such as `clarification` / `stage:product-docs` or `related_task_ids` containing `{{TASK_ID}}`. Do not dedupe by `title` alone.
+First, re-run `mcp__dotbot__decision_list({ status: "accepted" })`. The inbound funnel records mothership answers as accepted decisions *during* the needs-input pause, so they only show up now -- after Phase 1's earlier list.
+
+Then call `decision_create` for every ambiguity now resolved, **except** the ones already on record:
+
+- **Funnel already captured this answer.** For a user-answered question, if an accepted decision tagged `inbound:mothership` already covers it -- its title is `Inbound answer: <the question text>` and its `related_task_ids` contains `{{TASK_ID}}` -- do NOT create a second record. The funnel owns it.
+- **Re-run duplicate.** Skip when the earlier list already returned an accepted decision for the same planning item: same `title` and at least one scope match (overlapping `clarification` / `stage:product-docs` tags, or `related_task_ids` containing `{{TASK_ID}}`). Do not dedupe by `title` alone.
+
+Still `decision_create` for: (a) every **agent-decidable** ambiguity you resolved without asking -- the funnel never captures these; and (b) any **user-answered** question that has NO matching `inbound:mothership` decision (e.g. mothership is disabled, so the answer came in through the dashboard, not the funnel).
 
 ```
 mcp__dotbot__decision_create({
@@ -356,4 +363,4 @@ If, after Phase 3, no user-blocking question remained (everything was agent-deci
 - `tech-stack.md` covers the seven sections (Languages, Frameworks, Libraries, Tooling, Infrastructure, Dev Env, Rationale). Rationale references decision IDs where applicable.
 - `entity-model.md` includes at least one entity, all referenced enums, a Mermaid `erDiagram`, a Data Storage section, and a Design Decisions section that references decision IDs where applicable.
 - Every material ambiguity surfaced during planning has either a Decision record (status `accepted`) or is reflected in deliverable prose. Nothing is parked as an open question.
-- For each user-answered question in `questions_resolved`, a Decision exists with matching `title` and `tags` containing `clarification` and `stage:product-docs`.
+- For each user-answered question in `questions_resolved`, a Decision exists -- either a Phase-4 decision tagged `clarification` + `stage:product-docs`, or a funnel decision tagged `inbound:mothership` (related to `{{TASK_ID}}`) that already captured that answer.
diff --git a/content/workflows/start-from-prompt/prompts/01b-generate-decisions.md b/content/workflows/start-from-prompt/prompts/01b-generate-decisions.md
index 8c5c1ac8..44a03398 100644
--- a/content/workflows/start-from-prompt/prompts/01b-generate-decisions.md
+++ b/content/workflows/start-from-prompt/prompts/01b-generate-decisions.md
@@ -33,13 +33,13 @@ Issue all ToolSearch calls above in a **single parallel batch** during Phase 0.
 
 ### Step 0.5: List Existing Decisions
 
-Phase 1 (`01-plan-product.md`) already records decisions for clarification answers and for ambiguities the agent resolved during product-doc drafting. Load them so this stage does not duplicate:
+Phase 1 (`01-plan-product.md`) already records decisions for clarification answers and for ambiguities the agent resolved during product-doc drafting, and the inbound funnel records mothership answers as `inbound:mothership` decisions. Load them so this stage does not duplicate:
 
 ```
 mcp__dotbot__decision_list({ status: "accepted" })
 ```
 
-When iterating Step 2's candidates, skip any candidate whose `title` and relevant `tags` match a decision already returned here. Match by `title` and overlap of `tags` (especially `stage:product-docs` and `clarification`). Do not record a new decision when an existing one already covers the same choice.
+When iterating Step 2's candidates, skip any candidate whose `title` and relevant `tags` match a decision already returned here. Match by `title` and overlap of `tags` (especially `stage:product-docs`, `clarification`, and `inbound:mothership`). A candidate that just restates an answer already captured by an `inbound:mothership` decision is a duplicate -- skip it. Do not record a new decision when an existing one already covers the same choice.
 
 ### Step 1: Read Source Documents
 
@@ -74,7 +74,7 @@ Scan the source documents for decisions that meet ALL of these criteria:
 - Questions the user skipped
 - Implementation details that belong in task plans
 - Generic principles without a real trade-off
-- Items already recorded as decisions in Phase 1 (tag `stage:product-docs` or `clarification`)
+- Items already recorded as decisions in Phase 1 (tag `stage:product-docs` or `clarification`) or by the inbound funnel (tag `inbound:mothership`)
 
 Aim for **3–10 decisions** from a typical workflow run. Fewer is better than padding with non-decisions.
 
diff --git a/src/README.md b/src/README.md
index a5ebb4c2..d1815081 100644
--- a/src/README.md
+++ b/src/README.md
@@ -1,6 +1,6 @@
 # dotbot - Autonomous Development Framework
 
-A project-agnostic framework for autonomous software development across Claude Code, Codex, and Antigravity CLIs. Provides task management, two-phase execution (analysis + implementation), per-task git worktree isolation, a web dashboard, and a PowerShell MCP server.
+A project-agnostic framework for autonomous software development across Claude Code, Codex, and Antigravity CLIs. Provides task management, single-session task execution, per-task git worktree isolation, a web dashboard, and a PowerShell MCP server.
 
 ## Installation
 
@@ -64,37 +64,31 @@ dotbot go
 
 ## How It Works
 
-### Two-Phase Task Execution
+### Single-Session Task Execution
 
-Every task goes through two phases, each run by a separate provider CLI instance:
+Every task runs in one provider CLI session driven by `100-single-session-task.md`:
 
-**Phase 1 - Analysis** (`98-analyse-task.md`):
-- Identifies affected entities and files
-- Maps applicable coding standards
-- Validates dependencies
-- Produces concrete implementation guidance (insertion points, pattern snippets, field mappings)
-- Asks clarifying questions or proposes task splits if needed
-
-**Phase 2 - Execution** (`99-autonomous-task.md`):
-- Receives pre-packaged analysis context (no re-exploration needed)
-- Implements changes following the analysis guidance
+- Does focused discovery (or resumes from a `needs-input` handoff without re-exploring)
+- Loads applicable decisions and standards as binding constraints
+- Implements changes following existing project patterns
 - Runs verification scripts (privacy scan, git clean, build, format)
-- Commits with task ID references
+- Commits with task ID references and marks the task done
+
+If human input blocks progress, the session pauses on `needs-input` and resumes the same task once the question is answered. There is no separate analysis provider session.
 
 ### Per-Task Git Worktrees
 
 Each task runs in an isolated git worktree:
 
 ```
-Analysis picks up task
+Task-runner picks up task
   → Creates branch: task/{short-id}-{slug}
   → Creates worktree: ../worktrees/{repo}/task-{short-id}-{slug}/
   → Sets up junctions for shared .bot/ directories
   → Copies essential gitignored files (e.g., .env)
 
-Execution picks up analysed task
-  → Looks up existing worktree
-  → Provider CLI implements and commits to task branch
+Provider session runs in the worktree
+  → Discovers, implements, verifies, and commits to task branch
 
 On completion
   → Rebases task branch onto main
@@ -119,8 +113,7 @@ todo → analysing → analysed → in-progress → done
 
 | Type | Purpose |
 |------|---------|
-| `analysis` | Pre-flight task analysis |
-| `execution` | Task implementation |
+| `task-runner` | Single-session task execution loop |
 | `planning` | Roadmap generation |
 | `commit` | Git operations |
 | `task-creation` | Bulk task creation |
diff --git a/src/cli/workflow-add.ps1 b/src/cli/workflow-add.ps1
index 5a7ee884..9b2668cd 100644
--- a/src/cli/workflow-add.ps1
+++ b/src/cli/workflow-add.ps1
@@ -125,4 +125,21 @@ if (Test-Path $controlSettingsPath) {
 $existing | Add-Member -NotePropertyName 'workflow' -NotePropertyValue $displayName -Force
 $existing | ConvertTo-Json -Depth 10 | Set-Content -Path $controlSettingsPath -Encoding UTF8
 
+# Inbound decision funnel (issue #416): record workflow adoption as a process
+# decision. Best-effort -- a failure here must not fail the workflow add.
+try {
+    Import-Module (Join-Path $PSScriptRoot ".." "runtime" "Modules" "Dotbot.Decision" "Dotbot.Decision.psd1") -DisableNameChecking -Global -ErrorAction Stop
+    $wfNamespace = if ($Name -match '^([^:]+):(.+)$') { $Matches[1] } else { '' }
+    $null = New-InboundDecision -Source registry -BotPath $BotDir -Payload @{
+        action    = 'add'
+        namespace = $wfNamespace
+        workflow  = $displayName
+        title     = if ($wfNamespace) { "Adopt workflow $displayName from $wfNamespace" } else { "Adopt workflow $displayName" }
+    }
+} catch {
+    if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+        Write-BotLog -Level Warn -Message "Inbound decision funnel (registry add) failed" -Exception $_
+    }
+}
+
 Write-Success "Active workflow: $displayName"
diff --git a/src/cli/workflow-remove.ps1 b/src/cli/workflow-remove.ps1
index 9d2e7498..e15412f3 100644
--- a/src/cli/workflow-remove.ps1
+++ b/src/cli/workflow-remove.ps1
@@ -77,4 +77,21 @@ if (Test-Path $controlSettingsPath) {
     }
 }
 
+# Inbound decision funnel (issue #416): record workflow removal as a process
+# decision. Best-effort -- a failure here must not fail the workflow remove.
+try {
+    Import-Module (Join-Path $PSScriptRoot ".." "runtime" "Modules" "Dotbot.Decision" "Dotbot.Decision.psd1") -DisableNameChecking -Global -ErrorAction Stop
+    $wfNamespace = if ($Name -match '^([^:]+):(.+)$') { $Matches[1] } else { '' }
+    $null = New-InboundDecision -Source registry -BotPath $BotDir -Payload @{
+        action    = 'remove'
+        namespace = $wfNamespace
+        workflow  = $Name
+        title     = "Remove workflow $Name"
+    }
+} catch {
+    if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+        Write-BotLog -Level Warn -Message "Inbound decision funnel (registry remove) failed" -Exception $_
+    }
+}
+
 Write-Success "Workflow '$Name' removed."
diff --git a/src/mcp/tools/decision-create/script.ps1 b/src/mcp/tools/decision-create/script.ps1
index 50e4a672..0a746955 100644
--- a/src/mcp/tools/decision-create/script.ps1
+++ b/src/mcp/tools/decision-create/script.ps1
@@ -1,82 +1,13 @@
+# All decision generation lives in New-DecisionRecord on the Dotbot.Decision
+# runtime module -- the single point that owns the record shape, validation, and
+# write. Resolved relative to this tool script so it works in both the source
+# tree and a vendored .bot/src deployment (same relative layout in both).
+Import-Module (Join-Path $PSScriptRoot ".." ".." ".." "runtime" "Modules" "Dotbot.Decision" "Dotbot.Decision.psd1") -DisableNameChecking -Global
+
 function Invoke-DecisionCreate {
     param([hashtable]$Arguments)
 
-    $title = $Arguments['title']
-    $type = $Arguments['type'] ?? 'technical'
-    $context = $Arguments['context']
-    $decision = $Arguments['decision']
-    $consequences = $Arguments['consequences'] ?? ''
-    $alternativesRaw = $Arguments['alternatives_considered'] ?? @()
-    $stakeholders = $Arguments['stakeholders'] ?? @()
-    $relatedTaskIds = $Arguments['related_task_ids'] ?? @()
-    $relatedDecisionIds = $Arguments['related_decision_ids'] ?? @()
-    $tags = $Arguments['tags'] ?? @()
-    $impact = $Arguments['impact'] ?? 'medium'
-    $status = $Arguments['status'] ?? 'proposed'
-
-    if (-not $title) { throw "title is required" }
-    if (-not $context) { throw "context is required" }
-    if (-not $decision) { throw "decision is required" }
-
-    $validStatuses = @('proposed', 'accepted')
-    if ($status -notin $validStatuses) { throw "Invalid status '$status'. Must be one of: $($validStatuses -join ', ')" }
-
-    $validTypes = @('architecture', 'business', 'technical', 'process')
-    if ($type -notin $validTypes) { throw "Invalid type '$type'. Must be one of: $($validTypes -join ', ')" }
-
-    $validImpacts = @('high', 'medium', 'low')
-    if ($impact -notin $validImpacts) { throw "Invalid impact '$impact'. Must be one of: $($validImpacts -join ', ')" }
-
-    # Validate related_decision_ids format
-    $relatedDecisionIds = @($relatedDecisionIds | Where-Object { $_ -match '^dec-[a-f0-9]{8}$' })
-
-    # Ensure alternatives is array of objects
-    $alternatives = @()
-    foreach ($alt in $alternativesRaw) {
-        if ($alt -is [hashtable] -or $alt -is [PSCustomObject]) {
-            $alternatives += $alt
-        }
-    }
-
-    $id = "dec-" + ([guid]::NewGuid().ToString('N').Substring(0, 8))
-    $date = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd")
-
-    $slug = ($title -replace '[^\w\s-]', '' -replace '\s+', '-').ToLowerInvariant()
-    if ($slug.Length -gt 60) { $slug = $slug.Substring(0, 60).TrimEnd('-') }
-
-    $decisionsBaseDir = Join-Path (Get-DotbotProjectBotPath) "workspace" "decisions"
-    $targetDir = Join-Path $decisionsBaseDir $status
-    if (-not (Test-Path $targetDir)) { New-Item -ItemType Directory -Force -Path $targetDir | Out-Null }
-
-    $dec = @{
-        id = $id
-        title = $title
-        type = $type
-        status = $status
-        date = $date
-        context = $context
-        decision = $decision
-        consequences = $consequences
-        alternatives_considered = $alternatives
-        stakeholders = @($stakeholders)
-        related_task_ids = @($relatedTaskIds)
-        related_decision_ids = $relatedDecisionIds
-        supersedes = $null
-        superseded_by = $null
-        tags = @($tags)
-        impact = $impact
-        deprecation_reason = $null
-    }
-
-    $fileName = "$id-$slug.json"
-    $filePath = Join-Path $targetDir $fileName
-    $dec | ConvertTo-Json -Depth 10 | Set-Content -Path $filePath -Encoding UTF8
-
-    return @{
-        success = $true
-        decision_id = $id
-        status = $status
-        file_path = $filePath
-        message = "Decision '$title' created as $id ($status)"
-    }
+    # Pure caller, zero generation logic. The default status stays 'proposed'
+    # (set inside New-DecisionRecord) to preserve the AI-agent path's behaviour.
+    return New-DecisionRecord -Arguments $Arguments
 }
diff --git a/src/mcp/tools/decision-get/script.ps1 b/src/mcp/tools/decision-get/script.ps1
index 267cd43d..aabc8f73 100644
--- a/src/mcp/tools/decision-get/script.ps1
+++ b/src/mcp/tools/decision-get/script.ps1
@@ -5,7 +5,13 @@ function Invoke-DecisionGet {
     if (-not $decId) { throw "decision_id is required" }
     if ($decId -notmatch '^dec-[a-f0-9]{8}$') { throw "Invalid decision_id format '$decId'. Expected: dec-XXXXXXXX" }
 
-    $decisionsBaseDir = Join-Path (Get-DotbotProjectBotPath) "workspace" "decisions"
+    # Decisions are dotbot state in the MAIN repo (issue #515). The MCP server
+    # resolves the main root into $global:DotbotBotRoot; prefer it so decisions read
+    # or written from a linked worktree still target main (matching the runtime-
+    # backed task tools + dashboard). Fall back to the cwd walk when it is unset.
+    $stateBotRoot = if ((Test-Path Variable:global:DotbotBotRoot) -and $global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+
+    $decisionsBaseDir = Join-Path $stateBotRoot "workspace" "decisions"
     $allStatuses = @('proposed', 'accepted', 'deprecated', 'superseded')
 
     $found = $null
@@ -24,6 +30,17 @@ function Invoke-DecisionGet {
 
     $dec = Get-Content -Path $found.file.FullName -Raw | ConvertFrom-Json
 
+    # Audit: record which decision a task read during execution. Gives a
+    # per-task trail of which decisions (incl. inbound funnel ones) actually
+    # reached and were consumed by the agent. task id comes from the harness
+    # env, set on the executing task-runner.
+    if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+        $currentTaskId = $env:DOTBOT_CURRENT_TASK_ID
+        $tagStr = if ($dec.tags) { (@($dec.tags) -join ',') } else { '' }
+        Write-BotLog -Level Info -Message "decision_get: task '$currentTaskId' read $($dec.id) '$($dec.title)' [tags: $tagStr]" `
+            -Context @{ activity_type = 'decision_read'; decision_id = "$($dec.id)"; task_id = "$currentTaskId"; tags = $tagStr }
+    }
+
     return @{
         success = $true
         id = $dec.id
diff --git a/src/mcp/tools/decision-list/script.ps1 b/src/mcp/tools/decision-list/script.ps1
index 599bb2d5..26c2c5e3 100644
--- a/src/mcp/tools/decision-list/script.ps1
+++ b/src/mcp/tools/decision-list/script.ps1
@@ -2,7 +2,12 @@ function Invoke-DecisionList {
     param([hashtable]$Arguments)
 
     $filterStatus = $Arguments['status']
-    $decisionsBaseDir = Join-Path (Get-DotbotProjectBotPath) "workspace" "decisions"
+    # Decisions are dotbot state in the MAIN repo (issue #515). The MCP server
+    # resolves the main root into $global:DotbotBotRoot; prefer it so decisions read
+    # or written from a linked worktree still target main (matching the runtime-
+    # backed task tools + dashboard). Fall back to the cwd walk when it is unset.
+    $stateBotRoot = if ((Test-Path Variable:global:DotbotBotRoot) -and $global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+    $decisionsBaseDir = Join-Path $stateBotRoot "workspace" "decisions"
     $allStatuses = @('proposed', 'accepted', 'deprecated', 'superseded')
 
     if ($filterStatus -and $filterStatus -notin $allStatuses) {
@@ -38,6 +43,16 @@ function Invoke-DecisionList {
 
     $decisions = @($decisions | Sort-Object { $_.id })
 
+    # Audit: record the decision scan a task performed during execution -- which
+    # decisions were surfaced to the agent (incl. inbound funnel ones) and the
+    # status filter used. Pairs with the per-decision decision_read log.
+    if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+        $currentTaskId = $env:DOTBOT_CURRENT_TASK_ID
+        $ids = (@($decisions | ForEach-Object { $_.id })) -join ','
+        Write-BotLog -Level Info -Message "decision_list: task '$currentTaskId' status='$filterStatus' surfaced $($decisions.Count) decision(s): $ids" `
+            -Context @{ activity_type = 'decision_list'; task_id = "$currentTaskId"; count = $decisions.Count; filter = "$filterStatus" }
+    }
+
     return @{
         success = $true
         count = $decisions.Count
diff --git a/src/mcp/tools/decision-mark-accepted/script.ps1 b/src/mcp/tools/decision-mark-accepted/script.ps1
index 6d4a7283..531d4cde 100644
--- a/src/mcp/tools/decision-mark-accepted/script.ps1
+++ b/src/mcp/tools/decision-mark-accepted/script.ps1
@@ -5,7 +5,13 @@ function Invoke-DecisionMarkAccepted {
     if (-not $decId) { throw "decision_id is required" }
     if ($decId -notmatch '^dec-[a-f0-9]{8}$') { throw "Invalid decision_id format '$decId'. Expected: dec-XXXXXXXX" }
 
-    $decisionsBaseDir = Join-Path (Get-DotbotProjectBotPath) "workspace" "decisions"
+    # Decisions are dotbot state in the MAIN repo (issue #515). The MCP server
+    # resolves the main root into $global:DotbotBotRoot; prefer it so decisions read
+    # or written from a linked worktree still target main (matching the runtime-
+    # backed task tools + dashboard). Fall back to the cwd walk when it is unset.
+    $stateBotRoot = if ((Test-Path Variable:global:DotbotBotRoot) -and $global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+
+    $decisionsBaseDir = Join-Path $stateBotRoot "workspace" "decisions"
     $sourceDir = Join-Path $decisionsBaseDir "proposed"
 
     if (-not (Test-Path $sourceDir)) { throw "No proposed decisions directory found" }
diff --git a/src/mcp/tools/decision-mark-deprecated/script.ps1 b/src/mcp/tools/decision-mark-deprecated/script.ps1
index 5dd632c8..47a46f6e 100644
--- a/src/mcp/tools/decision-mark-deprecated/script.ps1
+++ b/src/mcp/tools/decision-mark-deprecated/script.ps1
@@ -6,7 +6,13 @@ function Invoke-DecisionMarkDeprecated {
     if (-not $decId) { throw "decision_id is required" }
     if ($decId -notmatch '^dec-[a-f0-9]{8}$') { throw "Invalid decision_id format '$decId'. Expected: dec-XXXXXXXX" }
 
-    $decisionsBaseDir = Join-Path (Get-DotbotProjectBotPath) "workspace" "decisions"
+    # Decisions are dotbot state in the MAIN repo (issue #515). The MCP server
+    # resolves the main root into $global:DotbotBotRoot; prefer it so decisions read
+    # or written from a linked worktree still target main (matching the runtime-
+    # backed task tools + dashboard). Fall back to the cwd walk when it is unset.
+    $stateBotRoot = if ((Test-Path Variable:global:DotbotBotRoot) -and $global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+
+    $decisionsBaseDir = Join-Path $stateBotRoot "workspace" "decisions"
     $allStatuses = @('proposed', 'accepted')
 
     $found = $null
diff --git a/src/mcp/tools/decision-mark-superseded/script.ps1 b/src/mcp/tools/decision-mark-superseded/script.ps1
index c08f2498..e9994332 100644
--- a/src/mcp/tools/decision-mark-superseded/script.ps1
+++ b/src/mcp/tools/decision-mark-superseded/script.ps1
@@ -8,7 +8,13 @@ function Invoke-DecisionMarkSuperseded {
     if (-not $supersededBy) { throw "superseded_by is required" }
     if ($supersededBy -notmatch '^dec-[a-f0-9]{8}$') { throw "Invalid superseded_by format '$supersededBy'. Expected: dec-XXXXXXXX" }
 
-    $decisionsBaseDir = Join-Path (Get-DotbotProjectBotPath) "workspace" "decisions"
+    # Decisions are dotbot state in the MAIN repo (issue #515). The MCP server
+    # resolves the main root into $global:DotbotBotRoot; prefer it so decisions read
+    # or written from a linked worktree still target main (matching the runtime-
+    # backed task tools + dashboard). Fall back to the cwd walk when it is unset.
+    $stateBotRoot = if ((Test-Path Variable:global:DotbotBotRoot) -and $global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+
+    $decisionsBaseDir = Join-Path $stateBotRoot "workspace" "decisions"
     $allStatuses = @('proposed', 'accepted')
 
     $found = $null
diff --git a/src/mcp/tools/decision-update/script.ps1 b/src/mcp/tools/decision-update/script.ps1
index 2a67c7c9..42457dcb 100644
--- a/src/mcp/tools/decision-update/script.ps1
+++ b/src/mcp/tools/decision-update/script.ps1
@@ -5,7 +5,14 @@ function Invoke-DecisionUpdate {
     if (-not $decId) { throw "decision_id is required" }
     if ($decId -notmatch '^dec-[a-f0-9]{8}$') { throw "Invalid decision_id format '$decId'. Expected: dec-XXXXXXXX" }
 
-    $decisionsBaseDir = Join-Path (Get-DotbotProjectBotPath) "workspace" "decisions"
+    # Decisions are dotbot state in the MAIN repo (issue #515). The MCP server
+    # resolves the main root into $global:DotbotBotRoot; prefer it so decisions read
+    # or written from a linked worktree still target main (matching the runtime-
+    # backed task tools + dashboard). Fall back to the cwd walk when it is unset.
+
+    $stateBotRoot = if ((Test-Path Variable:global:DotbotBotRoot) -and $global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+
+    $decisionsBaseDir = Join-Path $stateBotRoot "workspace" "decisions"
     $allStatuses = @('proposed', 'accepted', 'deprecated', 'superseded')
 
     $found = $null
diff --git a/src/packaging/homebrew/dotbot.rb b/src/packaging/homebrew/dotbot.rb
index ec5ae728..2fcf092e 100644
--- a/src/packaging/homebrew/dotbot.rb
+++ b/src/packaging/homebrew/dotbot.rb
@@ -1,5 +1,5 @@
 class Dotbot < Formula
-  desc "Structured AI-assisted development framework with two-phase execution"
+  desc "Structured AI-assisted development framework with single-session execution"
   homepage "https://github.com/andresharpe/dotbot"
   # Bootstrap from the current repository snapshot until the v4.0.0 release asset is published.
   url "https://github.com/andresharpe/dotbot/archive/59d58ea441921f977678f54f8ec8408bacdcb45f.tar.gz"
diff --git a/src/packaging/scoop/dotbot.json b/src/packaging/scoop/dotbot.json
index 8bea15c8..b5e7ab27 100644
--- a/src/packaging/scoop/dotbot.json
+++ b/src/packaging/scoop/dotbot.json
@@ -1,6 +1,6 @@
 {
     "version": "4.0.0",
-    "description": "Structured AI-assisted development framework with two-phase execution and web dashboard",
+    "description": "Structured AI-assisted development framework with single-session execution and web dashboard",
     "homepage": "https://github.com/andresharpe/dotbot",
     "license": "MIT",
     "url": "https://github.com/andresharpe/dotbot/releases/download/v4.0.0/dotbot-4.0.0.zip",
diff --git a/src/runtime/Modules/Dotbot.Content/Dotbot.Content.psm1 b/src/runtime/Modules/Dotbot.Content/Dotbot.Content.psm1
index 9cfd2cf5..00037b8a 100644
--- a/src/runtime/Modules/Dotbot.Content/Dotbot.Content.psm1
+++ b/src/runtime/Modules/Dotbot.Content/Dotbot.Content.psm1
@@ -89,7 +89,7 @@ function Resolve-DotbotContent {
 
     .PARAMETER Name
     Item name (e.g. 'implementer', 'start-from-prompt',
-    '98-analyse-task.md').
+    '100-single-session-task.md').
 
     .OUTPUTS
     [string] Absolute path, or $null.
diff --git a/src/runtime/Modules/Dotbot.Decision/Dotbot.Decision.psd1 b/src/runtime/Modules/Dotbot.Decision/Dotbot.Decision.psd1
new file mode 100644
index 00000000..96026b27
--- /dev/null
+++ b/src/runtime/Modules/Dotbot.Decision/Dotbot.Decision.psd1
@@ -0,0 +1,21 @@
+@{
+    RootModule        = 'Dotbot.Decision.psm1'
+    ModuleVersion     = '1.0.0'
+    GUID              = '4039f9a3-ef84-4ead-9df8-d41afb9aba07'
+    Author            = 'dotbot contributors'
+    Description       = 'Single point for managing decision records: the write primitive (New-DecisionRecord) and the inbound decision funnel (New-InboundDecision) that promotes mothership answers, workflow registry changes, and material settings changes to first-class decision records.'
+    PowerShellVersion = '7.0'
+
+    ScriptsToProcess  = @(
+        'Private/Imports.ps1'
+    )
+
+    FunctionsToExport = @(
+        'New-DecisionRecord'
+        'New-InboundDecision'
+    )
+
+    CmdletsToExport   = @()
+    VariablesToExport = @()
+    AliasesToExport   = @()
+}
diff --git a/src/runtime/Modules/Dotbot.Decision/Dotbot.Decision.psm1 b/src/runtime/Modules/Dotbot.Decision/Dotbot.Decision.psm1
new file mode 100644
index 00000000..ae3ab5be
--- /dev/null
+++ b/src/runtime/Modules/Dotbot.Decision/Dotbot.Decision.psm1
@@ -0,0 +1,480 @@
+<#
+.SYNOPSIS
+Single point for managing dotbot decision records.
+
+.DESCRIPTION
+This module owns everything about writing a decision record:
+
+1. New-DecisionRecord -- the write primitive. The ONLY code that generates a
+   record: id/slug/date generation, status/type/impact validation, the record
+   shape (including the optional external_ref provenance block), and the write
+   under <project>/.bot/workspace/decisions/<status>/. Both the MCP
+   decision_create tool (the AI-agent path) and the inbound funnel call it; no
+   one else re-implements generation.
+
+2. New-InboundDecision -- the inbound funnel. Promotes external events
+   (mothership answers, workflow registry changes, material settings changes)
+   to decision records. It owns ONLY mapping (event -> decision fields) and
+   dedup (idempotency key + cache + committed-record scan); it never generates
+   a record itself -- it calls New-DecisionRecord. Best-effort: a failure is
+   logged via Write-BotLog and never rethrown to the primary action.
+
+Dotbot.Core (paths) and Dotbot.Settings (merged state) are imported globally by
+Private/Imports.ps1. Callers may override the .bot path via -BotPath, which is
+how tests target a temp directory.
+#>
+
+#region Write primitive
+
+function New-DecisionRecord {
+    <#
+    .SYNOPSIS
+    Generate and persist a decision record. The single decision-write primitive.
+
+    .PARAMETER Arguments
+    Hashtable of decision fields. Recognised keys: title (required), context
+    (required), decision (required), type, consequences, alternatives_considered,
+    stakeholders, related_task_ids, related_decision_ids, tags, impact, status,
+    external_ref (@{ source; key; raw }).
+
+    .PARAMETER BotPath
+    Optional override of the project .bot path. Defaults to
+    Get-DotbotProjectBotPath. Used by tests to target a temp directory.
+
+    .OUTPUTS
+    Hashtable: @{ success; decision_id; status; file_path; message }.
+    #>
+    param(
+        [Parameter(Mandatory)][hashtable]$Arguments,
+        [string]$BotPath
+    )
+
+    $title = $Arguments['title']
+    $type = $Arguments['type'] ?? 'technical'
+    $context = $Arguments['context']
+    $decision = $Arguments['decision']
+    $consequences = $Arguments['consequences'] ?? ''
+    $alternativesRaw = $Arguments['alternatives_considered'] ?? @()
+    $stakeholders = $Arguments['stakeholders'] ?? @()
+    $relatedTaskIds = $Arguments['related_task_ids'] ?? @()
+    $relatedDecisionIds = $Arguments['related_decision_ids'] ?? @()
+    $tags = $Arguments['tags'] ?? @()
+    $impact = $Arguments['impact'] ?? 'medium'
+    $status = $Arguments['status'] ?? 'proposed'
+    $externalRef = $Arguments['external_ref']
+
+    if (-not $title) { throw "title is required" }
+    if (-not $context) { throw "context is required" }
+    if (-not $decision) { throw "decision is required" }
+
+    $validStatuses = @('proposed', 'accepted')
+    if ($status -notin $validStatuses) { throw "Invalid status '$status'. Must be one of: $($validStatuses -join ', ')" }
+
+    $validTypes = @('architecture', 'business', 'technical', 'process')
+    if ($type -notin $validTypes) { throw "Invalid type '$type'. Must be one of: $($validTypes -join ', ')" }
+
+    $validImpacts = @('high', 'medium', 'low')
+    if ($impact -notin $validImpacts) { throw "Invalid impact '$impact'. Must be one of: $($validImpacts -join ', ')" }
+
+    # Validate related_decision_ids format
+    $relatedDecisionIds = @($relatedDecisionIds | Where-Object { $_ -match '^dec-[a-f0-9]{8}$' })
+
+    # Ensure alternatives is array of objects
+    $alternatives = @()
+    foreach ($alt in $alternativesRaw) {
+        if ($alt -is [hashtable] -or $alt -is [PSCustomObject]) {
+            $alternatives += $alt
+        }
+    }
+
+    $id = "dec-" + ([guid]::NewGuid().ToString('N').Substring(0, 8))
+    $date = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd")
+
+    $slug = ($title -replace '[^\w\s-]', '' -replace '\s+', '-').ToLowerInvariant()
+    if ($slug.Length -gt 60) { $slug = $slug.Substring(0, 60).TrimEnd('-') }
+
+    # Decisions are dotbot state and live in the MAIN repo (issue #515). The MCP
+    # server resolves that main root into $global:DotbotBotRoot; prefer it so a
+    # decision written from a linked worktree still lands in main (matching the
+    # runtime-backed task tools and the dashboard). Fall back to the cwd walk when
+    # the global is unset (e.g. tests). An explicit -BotPath always wins.
+    $botPathResolved = if ($BotPath) { $BotPath } elseif ($global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+    $decisionsBaseDir = Join-Path $botPathResolved "workspace" "decisions"
+    $targetDir = Join-Path $decisionsBaseDir $status
+    if (-not (Test-Path $targetDir)) { New-Item -ItemType Directory -Force -Path $targetDir | Out-Null }
+
+    $dec = @{
+        id = $id
+        title = $title
+        type = $type
+        status = $status
+        date = $date
+        context = $context
+        decision = $decision
+        consequences = $consequences
+        alternatives_considered = $alternatives
+        stakeholders = @($stakeholders)
+        related_task_ids = @($relatedTaskIds)
+        related_decision_ids = $relatedDecisionIds
+        supersedes = $null
+        superseded_by = $null
+        tags = @($tags)
+        impact = $impact
+        deprecation_reason = $null
+        external_ref = $externalRef
+    }
+
+    $fileName = "$id-$slug.json"
+    $filePath = Join-Path $targetDir $fileName
+    $dec | ConvertTo-Json -Depth 10 | Set-Content -Path $filePath -Encoding UTF8
+
+    return @{
+        success = $true
+        decision_id = $id
+        status = $status
+        file_path = $filePath
+        message = "Decision '$title' created as $id ($status)"
+    }
+}
+
+#endregion
+
+#region Inbound funnel
+
+# The material settings allow-list. Per-key: only these settings produce a
+# decision record; every other key (costs.*, editor.*, logging.*, the
+# non-enabled mothership.* connection keys, etc.) is intentionally skipped.
+# This is the only place the settings vocabulary lives (issue #416, Q1).
+$script:InboundSettingsAllowList = @(
+    'provider'
+    'analysis.model'
+    'execution.model'
+    'analysis.auto_approve_splits'
+    'analysis.mode'
+    'file_listener.watchers'
+    'mothership.enabled'
+)
+
+function Get-InboundDedupDir {
+    param([Parameter(Mandatory)][string]$BotPath)
+    return (Join-Path $BotPath ".control" "decisions-inbound")
+}
+
+function Get-InboundKeyHash {
+    # Stable filename for an idempotency key. The key may contain '/', ':', and
+    # other path-unsafe characters, so the cache file is named by hash and the
+    # full key is stored inside it.
+    param([Parameter(Mandatory)][string]$Key)
+    $sha = [System.Security.Cryptography.SHA256]::Create()
+    try {
+        $hash = [System.BitConverter]::ToString(
+            $sha.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($Key))) -replace '-', ''
+    } finally {
+        $sha.Dispose()
+    }
+    return $hash.Substring(0, 32).ToLowerInvariant()
+}
+
+function Test-InboundDuplicate {
+    <#
+    .SYNOPSIS
+    Returns $true if a record with this idempotency key already exists.
+
+    .DESCRIPTION
+    Fast path: a cache file under .control/decisions-inbound/. Durable fallback
+    (fresh clone, empty cache): scan committed records' external_ref.key. The
+    committed records are the source of truth; the cache is only a fast path.
+    #>
+    param(
+        [Parameter(Mandatory)][string]$Key,
+        [Parameter(Mandatory)][string]$BotPath
+    )
+
+    $cacheFile = Join-Path (Get-InboundDedupDir -BotPath $BotPath) ((Get-InboundKeyHash -Key $Key) + ".json")
+    if (Test-Path $cacheFile) { return $true }
+
+    $decisionsDir = Join-Path $BotPath "workspace" "decisions"
+    if (-not (Test-Path $decisionsDir)) { return $false }
+
+    foreach ($file in (Get-ChildItem -Path $decisionsDir -Recurse -Filter '*.json' -File -ErrorAction SilentlyContinue)) {
+        try {
+            $record = Get-Content $file.FullName -Raw | ConvertFrom-Json -ErrorAction Stop
+        } catch {
+            continue
+        }
+        if ($record.PSObject.Properties['external_ref'] -and $record.external_ref -and
+            $record.external_ref.PSObject.Properties['key'] -and "$($record.external_ref.key)" -eq $Key) {
+            return $true
+        }
+    }
+
+    return $false
+}
+
+function Write-InboundDedupCache {
+    <#
+    .SYNOPSIS
+    Record that an inbound key has been processed. Atomic create; never throws.
+
+    .DESCRIPTION
+    Uses FileMode.CreateNew (atomic, fails if the file already exists) mirroring
+    Request-ProcessLock in Dotbot.Process -- two concurrent runs that race past
+    the dedup check both attempt the create; the loser's IOException is swallowed.
+    #>
+    param(
+        [Parameter(Mandatory)][string]$Key,
+        [Parameter(Mandatory)][string]$DecisionId,
+        [Parameter(Mandatory)][string]$BotPath
+    )
+
+    $dir = Get-InboundDedupDir -BotPath $BotPath
+    if (-not (Test-Path $dir)) { New-Item -ItemType Directory -Force -Path $dir | Out-Null }
+    $cacheFile = Join-Path $dir ((Get-InboundKeyHash -Key $Key) + ".json")
+
+    $payload = @{ key = $Key; decision_id = $DecisionId; written_at = (Get-Date).ToUniversalTime().ToString("o") } |
+        ConvertTo-Json -Depth 5
+    $bytes = [System.Text.Encoding]::UTF8.GetBytes($payload)
+
+    try {
+        $fs = [System.IO.File]::Open($cacheFile, [System.IO.FileMode]::CreateNew, [System.IO.FileAccess]::Write, [System.IO.FileShare]::None)
+        try {
+            $fs.Write($bytes, 0, $bytes.Length)
+        } finally {
+            $fs.Close()
+        }
+    } catch [System.IO.IOException] {
+        # Another run created the cache file first -- harmless.
+    }
+}
+
+function ConvertTo-InboundMothershipFields {
+    # Mothership answer -> decision fields. One answer shape across both hook
+    # sites (issue #416 correction 2). Type mapping is the rigid Q8 table.
+    param([Parameter(Mandatory)][hashtable]$Payload)
+
+    $questionType = "$($Payload['questionType'])"
+    $answer = "$($Payload['answer'])"
+    $questionText = if ($Payload['questionText']) { "$($Payload['questionText'])" } else { $null }
+    $questionId = "$($Payload['questionId'])"
+    $taskId = "$($Payload['taskId'])"
+    $options = $Payload['options']
+    $relatedTaskIds = if ($Payload['relatedTaskIds']) { @($Payload['relatedTaskIds']) } elseif ($taskId) { @($taskId) } else { @() }
+
+    # The mothership answer for an option question is the bare option key (e.g.
+    # "B"). A bare key is meaningless to the analysis/execution reader, so resolve
+    # it against the question options to the "<key> - <label>" form (matching
+    # Resolve-TaskInputAnswer) and carry the option rationale into consequences.
+    # The pause-pattern question carries no explicit type; when options are
+    # present treat it as a single-choice answer.
+    $matched = Get-InboundOptionMatch -Options $options -Key $answer
+    if (-not $questionType -and $matched) { $questionType = 'singleChoice' }
+
+    $decisionText = if ($matched) { "$answer - $($matched.label)" } else { $answer }
+    $consequences = if ($matched) { "$($matched.rationale)" } else { '' }
+
+    $requiresReview = $false
+    $type =
+        switch ($questionType) {
+            'approval'        { 'process' }
+            'priorityRanking' { 'business' }
+            'freeText'        { $requiresReview = $true; 'process' }
+            'singleChoice'    { 'process' }
+            default           { 'process' }
+        }
+
+    $status = if ($requiresReview) { 'proposed' } else { 'accepted' }
+    $title = if ($questionText) { "Inbound answer: $questionText" } else { "Inbound answer for question $questionId" }
+    $context = if ($questionText) {
+        "Answer to '$questionText' received via mothership on task ${taskId}: $decisionText."
+    } else {
+        "Answer received via mothership for question $questionId on task ${taskId}: $decisionText."
+    }
+
+    return @{
+        title = $title
+        type = $type
+        status = $status
+        impact = 'medium'
+        context = $context
+        decision = $decisionText
+        consequences = $consequences
+        related_task_ids = $relatedTaskIds
+        tags = @('inbound:mothership')
+    }
+}
+
+function Get-InboundOptionMatch {
+    # Resolve a bare option key (e.g. "B") against a question's options array to
+    # the matching option's label + rationale. Options may be hashtables (tests)
+    # or PSCustomObjects (task JSON). Returns $null when there is no single-key
+    # match (approval / freeText / priorityRanking answers fall through).
+    param($Options, [string]$Key)
+
+    if (-not $Options -or [string]::IsNullOrWhiteSpace($Key)) { return $null }
+
+    foreach ($opt in @($Options)) {
+        if (-not $opt) { continue }
+        $k = if ($opt -is [System.Collections.IDictionary]) { $opt['key'] }
+             elseif ($opt.PSObject.Properties['key']) { $opt.key } else { $null }
+        if ("$k" -ne "$Key") { continue }
+
+        $label = if ($opt -is [System.Collections.IDictionary]) { $opt['label'] }
+                 elseif ($opt.PSObject.Properties['label']) { $opt.label } else { $null }
+        $rationale = if ($opt -is [System.Collections.IDictionary]) { $opt['rationale'] }
+                     elseif ($opt.PSObject.Properties['rationale']) { $opt.rationale } else { $null }
+        return @{ label = "$label"; rationale = "$rationale" }
+    }
+    return $null
+}
+
+function ConvertTo-InboundRegistryFields {
+    # Workflow registry add/remove -> decision fields.
+    param([Parameter(Mandatory)][hashtable]$Payload)
+
+    $workflow = "$($Payload['workflow'])"
+    $title = if ($Payload['title']) { "$($Payload['title'])" } else { "Workflow registry change: $workflow" }
+    $action = "$($Payload['action'])"
+
+    return @{
+        title = $title
+        type = 'process'
+        status = 'accepted'
+        impact = 'medium'
+        context = "Workflow registry change ($action) for workflow '$workflow'."
+        decision = $title
+        tags = @('inbound:registry')
+    }
+}
+
+function ConvertTo-InboundSettingsFields {
+    # Material settings change -> decision fields. Returns $null for any key not
+    # on the allow-list (the caller treats $null as "skip, no record").
+    param([Parameter(Mandatory)][hashtable]$Payload)
+
+    $key = "$($Payload['key'])"
+    if ($key -notin $script:InboundSettingsAllowList) { return $null }
+
+    $before = if ($Payload.ContainsKey('before')) { "$($Payload['before'])" } else { '' }
+    $after = if ($Payload.ContainsKey('after')) { "$($Payload['after'])" } else { '' }
+
+    # provider change and mothership enablement are the high-impact settings.
+    $impact = if ($key -in @('provider', 'mothership.enabled')) { 'high' } else { 'medium' }
+
+    return @{
+        title = "Settings change: $key"
+        type = 'process'
+        status = 'accepted'
+        impact = $impact
+        context = "Setting '$key' changed from '$before' to '$after'."
+        decision = "Set $key = $after"
+        tags = @('inbound:settings')
+    }
+}
+
+function Get-InboundIdempotencyKey {
+    param(
+        [Parameter(Mandatory)][string]$Source,
+        [Parameter(Mandatory)][hashtable]$Payload
+    )
+
+    switch ($Source) {
+        'mothership' {
+            return "mothership:$($Payload['projectId'])/$($Payload['questionId'])/$($Payload['instanceId'])"
+        }
+        'registry' {
+            return "registry:$($Payload['action']):$($Payload['namespace']):$($Payload['workflow'])"
+        }
+        'settings' {
+            $key = "$($Payload['key'])"
+            $before = if ($Payload.ContainsKey('before')) { "$($Payload['before'])" } else { '' }
+            $after = if ($Payload.ContainsKey('after')) { "$($Payload['after'])" } else { '' }
+            $hash = Get-InboundKeyHash -Key "$before|$after"
+            return "settings:${key}:$hash"
+        }
+        default {
+            return "${Source}:$([guid]::NewGuid().ToString('N'))"
+        }
+    }
+}
+
+function New-InboundDecision {
+    <#
+    .SYNOPSIS
+    The inbound decision funnel. Promotes an external event to a decision record.
+
+    .DESCRIPTION
+    Owns mapping (event -> decision fields) and dedup (idempotency key + cache +
+    committed-record scan) ONLY. Generation is delegated to New-DecisionRecord.
+    Best-effort: any failure is logged via Write-BotLog and NOT rethrown, so the
+    primary action (answer write-back, workflow add/remove, settings save) always
+    completes (issue #416, Q3).
+
+    .PARAMETER Source
+    One of: mothership, registry, settings.
+
+    .PARAMETER Payload
+    Source-specific event data. See the ConvertTo-Inbound*Fields helpers and
+    Get-InboundIdempotencyKey for the per-source key set.
+
+    .PARAMETER BotPath
+    Optional override of the project .bot path. Defaults to Get-DotbotProjectBotPath.
+
+    .OUTPUTS
+    The New-DecisionRecord result hashtable on write, or $null when skipped
+    (duplicate, non-material settings key, or a swallowed failure).
+    #>
+    param(
+        [Parameter(Mandatory)][ValidateSet('mothership', 'registry', 'settings')][string]$Source,
+        [Parameter(Mandatory)][hashtable]$Payload,
+        [string]$BotPath
+    )
+
+    try {
+        # Decisions are dotbot state and live in the MAIN repo (issue #515). The MCP
+    # server resolves that main root into $global:DotbotBotRoot; prefer it so a
+    # decision written from a linked worktree still lands in main (matching the
+    # runtime-backed task tools and the dashboard). Fall back to the cwd walk when
+    # the global is unset (e.g. tests). An explicit -BotPath always wins.
+    $botPathResolved = if ($BotPath) { $BotPath } elseif ($global:DotbotBotRoot) { $global:DotbotBotRoot } else { Get-DotbotProjectBotPath }
+
+        $fields =
+            switch ($Source) {
+                'mothership' { ConvertTo-InboundMothershipFields -Payload $Payload }
+                'registry'   { ConvertTo-InboundRegistryFields -Payload $Payload }
+                'settings'   { ConvertTo-InboundSettingsFields -Payload $Payload }
+            }
+
+        # Settings funnel returns $null for non-material keys -- skip silently.
+        if (-not $fields) { return $null }
+
+        $key = Get-InboundIdempotencyKey -Source $Source -Payload $Payload
+
+        if (Test-InboundDuplicate -Key $key -BotPath $botPathResolved) { return $null }
+
+        $fields['external_ref'] = @{
+            source = $Source
+            key = $key
+            raw = $Payload
+        }
+
+        $result = New-DecisionRecord -Arguments $fields -BotPath $botPathResolved
+
+        if ($result -and $result.success) {
+            Write-InboundDedupCache -Key $key -DecisionId $result.decision_id -BotPath $botPathResolved
+        }
+
+        return $result
+    } catch {
+        if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+            Write-BotLog -Level Warn -Message "Inbound decision funnel failed (source: $Source)" -Exception $_
+        }
+        return $null
+    }
+}
+
+#endregion
+
+Export-ModuleMember -Function @(
+    'New-DecisionRecord'
+    'New-InboundDecision'
+)
diff --git a/src/runtime/Modules/Dotbot.Decision/Private/Imports.ps1 b/src/runtime/Modules/Dotbot.Decision/Private/Imports.ps1
new file mode 100644
index 00000000..c9aa1521
--- /dev/null
+++ b/src/runtime/Modules/Dotbot.Decision/Private/Imports.ps1
@@ -0,0 +1,9 @@
+# Dotbot.Decision depends on Dotbot.Core for path resolution
+# (Get-DotbotProjectBotPath) and Dotbot.Settings for reading merged state.
+# Imported -Global so the exported functions resolve them regardless of the
+# load order at each caller site (MCP tool, poller, CLI, settings API).
+$moduleRoot = Split-Path -Parent $PSScriptRoot
+$runtimeModules = Split-Path -Parent $moduleRoot
+
+Import-Module (Join-Path $runtimeModules 'Dotbot.Core' 'Dotbot.Core.psd1') -DisableNameChecking -Global
+Import-Module (Join-Path $runtimeModules 'Dotbot.Settings' 'Dotbot.Settings.psd1') -DisableNameChecking -Global
diff --git a/src/runtime/Modules/Dotbot.Notification/Private/Envelope.ps1 b/src/runtime/Modules/Dotbot.Notification/Private/Envelope.ps1
index 54a564d4..a12051e6 100644
--- a/src/runtime/Modules/Dotbot.Notification/Private/Envelope.ps1
+++ b/src/runtime/Modules/Dotbot.Notification/Private/Envelope.ps1
@@ -147,7 +147,7 @@ function Get-NotificationEnvelopeAnswer {
     $answerString =
         switch ($type) {
             'approval'        { if ($approvalDecision) { "$approvalDecision" } else { $null } }
-            'singleChoice'    { if ($selectedKey)      { "$selectedKey" }      else { $null } }
+            'singleChoice'    { if ($selectedKey)      { "$selectedKey" }      elseif ($freeText) { "$freeText" } else { $null } }
             'freeText'        { if ($freeText)         { "$freeText" }         else { $null } }
             'priorityRanking' { if ($rankedItems.Count -gt 0) { (@($rankedItems) | Sort-Object rank | ForEach-Object { "$($_.optionId)" }) -join ', ' } else { $null } }
             default {
diff --git a/src/runtime/Modules/Dotbot.Runtime/Private/HttpServer.psm1 b/src/runtime/Modules/Dotbot.Runtime/Private/HttpServer.psm1
index 60314571..71d2442c 100644
--- a/src/runtime/Modules/Dotbot.Runtime/Private/HttpServer.psm1
+++ b/src/runtime/Modules/Dotbot.Runtime/Private/HttpServer.psm1
@@ -1253,6 +1253,7 @@ function Invoke-TaskStatusHandler {
             $runContext = @{
                 BotRoot  = $BotRoot
                 Actor    = $actor
+                TaskPath = $path
             }
             if ($task.provenance -and $task.provenance.run_id) {
                 $bundle = _Read-RunRecord -BotRoot $BotRoot -RunId $task.provenance.run_id
diff --git a/src/runtime/Modules/Dotbot.Task/Dotbot.Task.psm1 b/src/runtime/Modules/Dotbot.Task/Dotbot.Task.psm1
index bca86c86..0a4cad84 100644
--- a/src/runtime/Modules/Dotbot.Task/Dotbot.Task.psm1
+++ b/src/runtime/Modules/Dotbot.Task/Dotbot.Task.psm1
@@ -1441,12 +1441,23 @@ function Invoke-InterviewLoop {
 
     $processData = $ProcessData
 
-    # Load interview prompt template
-    $interviewWorkflowPath = Join-Path $BotRoot "recipes/prompts/00-interview.md"
-    $interviewWorkflow = ""
-    if (Test-Path $interviewWorkflowPath) {
-        $interviewWorkflow = Get-Content $interviewWorkflowPath -Raw
+    # Load interview prompt template. Interview is a runtime task type, so its
+    # prompt lives globally under content/prompts/00-interview.md, resolved
+    # through the content hierarchy by Resolve-DotbotContentReference: project
+    # override (<BotRoot>/content/prompts) -> user -> framework/DOTBOT_HOME.
+    # A missing template is a hard failure -- the loop cannot produce a valid
+    # clarification-questions.json without the schema it carries.
+    $interviewWorkflowPath = $null
+    if (-not (Get-Command Resolve-DotbotContentReference -ErrorAction SilentlyContinue)) {
+        Import-Module (Join-Path $PSScriptRoot ".." "Dotbot.Content" "Dotbot.Content.psm1") -DisableNameChecking -Global -ErrorAction SilentlyContinue
     }
+    if (Get-Command Resolve-DotbotContentReference -ErrorAction SilentlyContinue) {
+        $interviewWorkflowPath = Resolve-DotbotContentReference -BotRoot $BotRoot -Type prompts -Reference '00-interview.md'
+    }
+    if (-not ($interviewWorkflowPath -and (Test-Path -LiteralPath $interviewWorkflowPath -PathType Leaf))) {
+        throw "Interview prompt '00-interview.md' not found in project (<BotRoot>/content/prompts/) or DOTBOT_HOME content (<DOTBOT_HOME>/content/prompts/)."
+    }
+    $interviewWorkflow = Get-Content -LiteralPath $interviewWorkflowPath -Raw
 
     # Check for briefing files
     $briefingDir = Join-Path $ProductDir "briefing"
@@ -1638,6 +1649,41 @@ Review all context above. Decide whether to write clarification-questions.json (
                                 if ($resolved) {
                                     $teamsAnswers[$qId] = $resolved
                                     Write-Status "Received Teams answer for $qId : $($resolved.answer)" -Type Info
+
+                                    # Inbound decision funnel (issue #416): promote this
+                                    # interview answer to a decision record. Best-effort --
+                                    # the funnel swallows its own failures and this guard
+                                    # keeps a polling tick alive if the module is absent.
+                                    try {
+                                        if (-not (Get-Command New-InboundDecision -ErrorAction SilentlyContinue)) {
+                                            Import-Module (Join-Path $PSScriptRoot ".." "Dotbot.Decision" "Dotbot.Decision.psd1") -DisableNameChecking -Global -ErrorAction Stop
+                                        }
+                                        $iq = $questions | Where-Object { "$($_.id)" -eq "$qId" } | Select-Object -First 1
+                                        $iqType = if ($iq -and @($iq.options).Count -gt 0) { 'singleChoice' } else { 'freeText' }
+                                        # Decisions are dotbot state and live in the MAIN repo
+                                        # (issue #515), where decision_create / decision_list and
+                                        # the dashboard resolve them -- NOT the linked worktree
+                                        # ($BotRoot here), where Complete-TaskWorktree would discard
+                                        # them. The interview executor exports the main root as
+                                        # DOTBOT_STATE_ROOT; write the record there.
+                                        $stateRoot = $env:DOTBOT_STATE_ROOT
+                                        $decisionBot = if ($stateRoot -and (Test-Path -LiteralPath (Join-Path $stateRoot '.bot'))) {
+                                            Join-Path $stateRoot '.bot'
+                                        } else { $BotRoot }
+                                        $null = New-InboundDecision -Source mothership -BotPath $decisionBot -Payload @{
+                                            questionType   = $iqType
+                                            questionText   = if ($iq) { "$($iq.question)" } else { $null }
+                                            options        = if ($iq) { $iq.options } else { $null }
+                                            answer         = "$($resolved.answer)"
+                                            questionId     = "$($notif.question_id)"
+                                            projectId      = "$($notif.project_id)"
+                                            instanceId     = "$($notif.instance_id)"
+                                            taskId         = $TaskId
+                                            relatedTaskIds = if ($TaskId) { @($TaskId) } else { @() }
+                                        }
+                                    } catch {
+                                        Write-BotLog -Level Warn -Message "Inbound decision funnel (interview) failed" -Exception $_
+                                    }
                                 }
                             }
                         } catch { Write-BotLog -Level Warn -Message "Teams polling attempt failed" -Exception $_ }
diff --git a/src/runtime/Plugins/Executors/interview/script.ps1 b/src/runtime/Plugins/Executors/interview/script.ps1
index 1c9e6103..58f6a41d 100644
--- a/src/runtime/Plugins/Executors/interview/script.ps1
+++ b/src/runtime/Plugins/Executors/interview/script.ps1
@@ -15,9 +15,39 @@ function Invoke-Executor {
         }
     }
 
+    # This executor runs in a fresh child runspace (default ISS). Invoke-InterviewLoop
+    # relies on commands the runtime normally imports globally -- Write-Status
+    # (Dotbot.Theme), Write-ProcessFile / Write-ProcessActivity / Add-JsonFrontMatter
+    # (Dotbot.Process), New-HarnessSession / Invoke-HarnessStream (Dotbot.Harness),
+    # Assert-TaskInputQuestionsData / Resolve-TaskInputAnswer (Dotbot.TaskInput).
+    # Put the runtime Modules dir on PSModulePath so PowerShell auto-loads any of
+    # them (and their transitive deps) on first use inside this runspace.
+    $modulesDir = Join-Path ([string]$RunContext['runtime_root']) 'Modules'
+    if ((Test-Path -LiteralPath $modulesDir) -and
+        (($env:PSModulePath -split [System.IO.Path]::PathSeparator) -notcontains $modulesDir)) {
+        $env:PSModulePath = $modulesDir + [System.IO.Path]::PathSeparator + $env:PSModulePath
+    }
+
     $taskModule = Join-Path ([string]$RunContext['runtime_root']) 'Modules' 'Dotbot.Task' 'Dotbot.Task.psd1'
     Import-Module $taskModule -Force -DisableNameChecking
 
+    # The child runspace does NOT inherit the parent's global variables, so the
+    # $global:DotbotProjectRoot the runner set to the worktree is absent here.
+    # The Claude harness falls back to $global:DotbotProjectRoot for Claude's cwd
+    # (ClaudeCodeAdapter), so without this the interview's Claude writes
+    # clarification-questions.json / interview-summary.md relative to the process
+    # cwd (the MAIN project) while Invoke-InterviewLoop looks under the worktree
+    # product_dir -- and reports "produced no output". Pin both globals to this
+    # task's execution roots so the harness writes where the loop reads.
+    if ($RunContext['project_root']) { $global:DotbotProjectRoot = [string]$RunContext['project_root'] }
+    if ($RunContext['bot_root'])     { $global:DotbotBotRoot     = [string]$RunContext['bot_root'] }
+    # dotbot STATE (task files, decisions) lives in the MAIN repo, not the
+    # worktree (issue #515). The child-process harness path exports this; the
+    # in-process path does not, so set it here from the run's state_root. The
+    # interview funnel hook writes inbound decisions to this main .bot so they
+    # match decision_create / decision_list and appear in the dashboard.
+    if ($RunContext['state_root']) { $env:DOTBOT_STATE_ROOT = [string]$RunContext['state_root'] }
+
     $botRoot = [string]$RunContext['bot_root']
     $productDir = [string]$RunContext['product_dir']
     $userPrompt = Resolve-InterviewPrompt -Task $Task -RunContext $RunContext
diff --git a/src/runtime/Plugins/Hooks/Transitions/enter-needs-input/metadata.json b/src/runtime/Plugins/Hooks/Transitions/enter-needs-input/metadata.json
new file mode 100644
index 00000000..6a196272
--- /dev/null
+++ b/src/runtime/Plugins/Hooks/Transitions/enter-needs-input/metadata.json
@@ -0,0 +1,7 @@
+{
+  "name": "enter-needs-input",
+  "description": "Best-effort: dispatch pending questions to mothership when a task enters needs-input, so answers can round-trip back through the notification poller. Advisory -- never aborts the transition.",
+  "target_statuses": ["needs-input"],
+  "max_duration": 60,
+  "abort_on_failure": false
+}
diff --git a/src/runtime/Plugins/Hooks/Transitions/enter-needs-input/script.ps1 b/src/runtime/Plugins/Hooks/Transitions/enter-needs-input/script.ps1
new file mode 100644
index 00000000..1b6535a4
--- /dev/null
+++ b/src/runtime/Plugins/Hooks/Transitions/enter-needs-input/script.ps1
@@ -0,0 +1,178 @@
+# ===============================================================
+# enter-needs-input -- Dotbot transition hook.
+#
+# Side effect when a task enters 'needs-input':
+#   - Dispatch its pending question(s) to mothership (Teams/email/etc.) via
+#     Send-TaskNotification, then persist a notifications map keyed by question
+#     id so the UI NotificationPoller can match answers back to the questions.
+#
+# This closes the outbound gap for the generic pause pattern
+# (task_update(pending_questions) + task_set_status(needs-input)), which -- unlike
+# the interview / review / split paths -- never dispatched to mothership before.
+#
+# Best-effort only: metadata sets abort_on_failure=false, so a delivery failure
+# is logged and never reverts the transition. Sending is gated on
+# mothership.enabled; sync_questions is intentionally NOT consulted (it is read
+# nowhere else in the codebase).
+# ===============================================================
+
+function Invoke-Hook {
+    param(
+        [Parameter(Mandatory)][hashtable]$Task,
+        [Parameter(Mandatory)][hashtable]$RunContext,
+        [Parameter(Mandatory)][string]$FromStatus,
+        [Parameter(Mandatory)][string]$ToStatus
+    )
+
+    $sw = [System.Diagnostics.Stopwatch]::StartNew()
+
+    try {
+        $botRoot  = if ($RunContext.ContainsKey('BotRoot'))  { $RunContext['BotRoot'] }  else { $null }
+        $taskPath = if ($RunContext.ContainsKey('TaskPath')) { $RunContext['TaskPath'] } else { $null }
+        if (-not $botRoot -or -not $taskPath) {
+            $sw.Stop()
+            return @{ Success = $true; Message = "enter-needs-input: no BotRoot/TaskPath in RunContext; skipped."; Duration = $sw.Elapsed }
+        }
+
+        # Locate the pending question(s). The generic pause pattern writes them
+        # under extensions.runner; the merge-failure single shape lives at the
+        # task root. Prefer runner, fall back to root.
+        $runner = $null
+        if ($Task.ContainsKey('extensions') -and $Task['extensions'] -is [hashtable] -and
+            $Task['extensions'].ContainsKey('runner') -and $Task['extensions']['runner'] -is [hashtable]) {
+            $runner = $Task['extensions']['runner']
+        }
+        $batch = $null; $single = $null
+        if ($runner) {
+            if     ($runner.ContainsKey('pending_questions') -and $runner['pending_questions']) { $batch  = @($runner['pending_questions']) }
+            elseif ($runner.ContainsKey('pending_question')  -and $runner['pending_question'])  { $single = $runner['pending_question'] }
+        }
+        if (-not $batch -and -not $single) {
+            if     ($Task.ContainsKey('pending_questions') -and $Task['pending_questions']) { $batch  = @($Task['pending_questions']) }
+            elseif ($Task.ContainsKey('pending_question')  -and $Task['pending_question'])  { $single = $Task['pending_question'] }
+        }
+        if (-not $batch -and -not $single) {
+            $sw.Stop()
+            return @{ Success = $true; Message = "enter-needs-input: no pending questions; nothing to dispatch."; Duration = $sw.Elapsed }
+        }
+
+        # This hook runs in an isolated child runspace, so import the runtime
+        # modules it needs (each guarded, following the enter-done precedent).
+        $frameworkRoot = if ($env:DOTBOT_HOME) {
+            $env:DOTBOT_HOME
+        } elseif (Get-Command Get-DotbotInstallPath -ErrorAction SilentlyContinue) {
+            Get-DotbotInstallPath
+        } else {
+            $null
+        }
+        if (-not $frameworkRoot) {
+            $sw.Stop()
+            return @{ Success = $true; Message = "enter-needs-input: DOTBOT_HOME unresolved; skipped."; Duration = $sw.Elapsed }
+        }
+        $modulesBase = Join-Path $frameworkRoot 'src/runtime/Modules'
+        if (-not (Get-Command Write-BotLog -ErrorAction SilentlyContinue)) {
+            Import-Module (Join-Path $modulesBase 'Dotbot.Logging/Dotbot.Logging.psd1') -DisableNameChecking -Global -ErrorAction SilentlyContinue
+        }
+        if (-not (Get-Command Send-TaskNotification -ErrorAction SilentlyContinue) -or
+            -not (Get-Command Get-NotificationSettings -ErrorAction SilentlyContinue)) {
+            Import-Module (Join-Path $modulesBase 'Dotbot.Notification/Dotbot.Notification.psd1') -DisableNameChecking -Global -ErrorAction Stop
+        }
+        if (-not (Get-Command Write-TaskFileAtomic -ErrorAction SilentlyContinue)) {
+            Import-Module (Join-Path $modulesBase 'Dotbot.TaskFile/Dotbot.TaskFile.psd1') -DisableNameChecking -Global -ErrorAction Stop
+        }
+
+        $settings = Get-NotificationSettings -BotRoot $botRoot
+        if (-not $settings.enabled) {
+            $sw.Stop()
+            return @{ Success = $true; Message = "enter-needs-input: mothership notifications disabled; skipped."; Duration = $sw.Elapsed }
+        }
+
+        $utc = (Get-Date).ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss'Z'")
+        $sent = 0
+        $total = 0
+
+        if ($batch) {
+            $total = @($batch).Count
+            $notifications = @{}
+            foreach ($pq in $batch) {
+                $qid = "$($pq.id)"
+                if (-not $qid) { continue }
+                try {
+                    $r = Send-TaskNotification -TaskContent $Task -PendingQuestion $pq -Settings $settings
+                    if ($r -and $r.success) {
+                        $notifications[$qid] = @{
+                            question_id = $r.question_id
+                            instance_id = $r.instance_id
+                            project_id  = $r.project_id
+                            channel     = $r.channel
+                            sent_at     = $utc
+                        }
+                        $sent++
+                    } elseif (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+                        $why = if ($r -and $r.reason) { $r.reason } else { 'unknown' }
+                        Write-BotLog -Level Warn -Message "enter-needs-input: send for question $qid failed: $why"
+                    }
+                } catch {
+                    if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+                        Write-BotLog -Level Warn -Message "enter-needs-input: send threw for question $qid" -Exception $_
+                    }
+                }
+            }
+            if ($notifications.Count -gt 0) {
+                # Re-read fresh (inside the task mutex) and merge the map into
+                # extensions.runner.notifications -- co-located with
+                # pending_questions, which is where the poller resolves it.
+                $fresh = Get-Content -LiteralPath $taskPath -Raw | ConvertFrom-Json -AsHashtable
+                if (-not $fresh.ContainsKey('extensions') -or $fresh['extensions'] -isnot [hashtable]) { $fresh['extensions'] = @{} }
+                if (-not $fresh['extensions'].ContainsKey('runner') -or $fresh['extensions']['runner'] -isnot [hashtable]) { $fresh['extensions']['runner'] = @{} }
+                $existing = if ($fresh['extensions']['runner'].ContainsKey('notifications') -and $fresh['extensions']['runner']['notifications'] -is [hashtable]) {
+                    $fresh['extensions']['runner']['notifications']
+                } else { @{} }
+                foreach ($k in $notifications.Keys) { $existing[$k] = $notifications[$k] }
+                $fresh['extensions']['runner']['notifications'] = $existing
+                Write-TaskFileAtomic -Path $taskPath -Content $fresh -Depth 20 -TaskId "$($fresh['id'])" -BotRoot $botRoot
+            }
+        } elseif ($single) {
+            $total = 1
+            try {
+                $r = Send-TaskNotification -TaskContent $Task -PendingQuestion $single -Settings $settings
+                if ($r -and $r.success) {
+                    $note = @{
+                        question_id = $r.question_id
+                        instance_id = $r.instance_id
+                        channel     = $r.channel
+                        project_id  = $r.project_id
+                        sent_at     = $utc
+                    }
+                    $fresh = Get-Content -LiteralPath $taskPath -Raw | ConvertFrom-Json -AsHashtable
+                    # Co-locate the note with its pending_question (root vs runner).
+                    if ($fresh.ContainsKey('pending_question')) {
+                        $fresh['notification'] = $note
+                    } else {
+                        if (-not $fresh.ContainsKey('extensions') -or $fresh['extensions'] -isnot [hashtable]) { $fresh['extensions'] = @{} }
+                        if (-not $fresh['extensions'].ContainsKey('runner') -or $fresh['extensions']['runner'] -isnot [hashtable]) { $fresh['extensions']['runner'] = @{} }
+                        $fresh['extensions']['runner']['notification'] = $note
+                    }
+                    Write-TaskFileAtomic -Path $taskPath -Content $fresh -Depth 20 -TaskId "$($fresh['id'])" -BotRoot $botRoot
+                    $sent = 1
+                } elseif (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+                    $why = if ($r -and $r.reason) { $r.reason } else { 'unknown' }
+                    Write-BotLog -Level Warn -Message "enter-needs-input: single-question send failed: $why"
+                }
+            } catch {
+                if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+                    Write-BotLog -Level Warn -Message "enter-needs-input: single-question send threw" -Exception $_
+                }
+            }
+        }
+
+        $sw.Stop()
+        return @{ Success = $true; Message = "enter-needs-input: dispatched $sent/$total question(s) to mothership."; Duration = $sw.Elapsed }
+    } catch {
+        # abort_on_failure=false keeps this non-aborting even on an uncaught throw.
+        $sw.Stop()
+        return @{ Success = $false; Message = "enter-needs-input failed: $($_.Exception.Message)"; Duration = $sw.Elapsed }
+    }
+}
+
+Export-ModuleMember -Function Invoke-Hook
diff --git a/src/runtime/Scripts/Invoke-WorkflowProcess.ps1 b/src/runtime/Scripts/Invoke-WorkflowProcess.ps1
index 3794cbfc..d6613122 100644
--- a/src/runtime/Scripts/Invoke-WorkflowProcess.ps1
+++ b/src/runtime/Scripts/Invoke-WorkflowProcess.ps1
@@ -447,6 +447,11 @@ function New-ExecutorRunContext {
         bot_root        = $contextBotRoot
         BotRoot         = $contextBotRoot
         project_root    = $contextProjectRoot
+        # Stable MAIN repo root (issue #515). project_root/bot_root point at the
+        # linked worktree during execution, but dotbot state (task files,
+        # decisions) lives in the main repo. In-process executors (interview) that
+        # write state must target this, not the worktree.
+        state_root      = $projectRoot
         runtime_root    = $runtimeRoot
         process_id      = $procId
         process_data    = $processData
@@ -1603,14 +1608,28 @@ try {
                 }
                 $typeSuccess = [bool]$executorResult['Success']
                 if (-not $typeSuccess) {
-                    $typeError = if ($executorResult.ContainsKey('Message')) { $executorResult['Message'] } else { "Executor returned Success=false" }
-                } elseif ($executorResult.ContainsKey('Message') -and $executorResult['Message']) {
+                    $typeError = if ($executorResult.Contains('Message')) { $executorResult['Message'] } else { "Executor returned Success=false" }
+                    # Persist the reason. Previously an executor that RETURNED
+                    # Success=false (rather than throwing) only surfaced via the
+                    # console Write-Status, so the failure reason never reached the
+                    # activity log / dotbot log -- leaving "Task failed" with no cause.
+                    Write-Status "Task type execution failed: $typeError" -Type Error
+                    Write-ProcessActivity -Id $procId -ActivityType "error" -Message "$($task.name): $typeError"
+                    if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+                        Write-BotLog -Level Error -Message "Executor returned failure for task $($task.name): $typeError" -ProcessId $procId
+                    }
+                } elseif ($executorResult.Contains('Message') -and $executorResult['Message']) {
                     Write-Diag "Executor result: $($executorResult['Message'])"
                 }
             } catch {
                 $typeError = $_.Exception.Message
                 Write-Status "Task type execution failed: $typeError" -Type Error
                 Write-ProcessActivity -Id $procId -ActivityType "error" -Message "$($task.name): $typeError"
+                # Preserve the stack so an executor crash is diagnosable (the
+                # message alone hides where in the executor chain it threw).
+                if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+                    Write-BotLog -Level Error -Message "Executor threw for task $($task.name): $typeError" -ProcessId $procId -Context @{ script_stack = "$($_.ScriptStackTrace)" }
+                }
             }
 
             # Post-script hook: run after successful executor work, before the
diff --git a/src/ui/modules/NotificationPoller.psm1 b/src/ui/modules/NotificationPoller.psm1
index 983fa98b..9ab671cb 100644
--- a/src/ui/modules/NotificationPoller.psm1
+++ b/src/ui/modules/NotificationPoller.psm1
@@ -15,6 +15,7 @@ if (-not (Get-Module TaskFile)) {
     Import-Module (Join-Path $PSScriptRoot ".." ".." "mcp" "modules" "TaskFile.psm1") -DisableNameChecking -Global
 }
 Import-Module (Join-Path $PSScriptRoot ".." ".." "runtime" "Modules" "Dotbot.TaskInput" "Dotbot.TaskInput.psd1") -Force -DisableNameChecking
+Import-Module (Join-Path $PSScriptRoot ".." ".." "runtime" "Modules" "Dotbot.Decision" "Dotbot.Decision.psd1") -DisableNameChecking -Global
 
 function Get-NotificationObjectProp {
     param($Object, [string]$Name)
@@ -28,6 +29,37 @@ function Get-NotificationObjectProp {
     return $null
 }
 
+function Invoke-NotificationInboundDecision {
+    # Inbound decision funnel (issue #416): promote a mothership answer to a
+    # decision record. Best-effort -- New-InboundDecision swallows its own
+    # failures, and this wrapper guards the call site too so a poller tick never
+    # fails on the audit side-effect.
+    param($PendingQuestion, $Notification, $Resolved, [string]$TaskId, [string]$BotRoot)
+    try {
+        # Decisions are dotbot state and live in the MAIN repository (issue #515):
+        # the MCP decision tools and the dashboard resolve them via the state root
+        # (git-common-dir), never a linked worktree. The poller runs in the
+        # UI server against the main checkout, so $BotRoot already points at the
+        # main .bot. Write there so the record matches decision_create / decision_list
+        # and shows in the dashboard immediately.
+        $null = New-InboundDecision -Source mothership -BotPath $BotRoot -Payload @{
+            questionType   = "$(Get-NotificationObjectProp -Object $PendingQuestion -Name 'type')"
+            questionText   = Get-NotificationObjectProp -Object $PendingQuestion -Name 'question'
+            options        = Get-NotificationObjectProp -Object $PendingQuestion -Name 'options'
+            answer         = "$($Resolved.answer)"
+            questionId     = "$(Get-NotificationObjectProp -Object $Notification -Name 'question_id')"
+            projectId      = "$(Get-NotificationObjectProp -Object $Notification -Name 'project_id')"
+            instanceId     = "$(Get-NotificationObjectProp -Object $Notification -Name 'instance_id')"
+            taskId         = $TaskId
+            relatedTaskIds = @($TaskId)
+        }
+    } catch {
+        if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+            Write-BotLog -Level Warn -Message "Inbound decision funnel (mothership poller) failed" -Exception $_
+        }
+    }
+}
+
 function Get-NotificationTaskRunner {
     param($TaskContent)
     $extensions = Get-NotificationObjectProp -Object $TaskContent -Name 'extensions'
@@ -221,6 +253,8 @@ function Invoke-NotificationPollTick {
                         Invoke-TaskTransitionFromNotification -TaskFile $taskFile -TaskContent $taskContent `
                             -Answer $resolved.answer -Attachments $resolved.attachments -BotRoot $botRoot `
                             -Comment $comment -RankedItems $rankedItems -ReviewedAttachmentIds $reviewedIds
+                        Invoke-NotificationInboundDecision -PendingQuestion $pendingQuestion -Notification $notification `
+                            -Resolved $resolved -TaskId $taskId -BotRoot $botRoot
                     }
                 }
                 continue
@@ -259,6 +293,8 @@ function Invoke-NotificationPollTick {
                 Invoke-BatchQuestionTransitionFromNotification -TaskFile $taskFile -TaskContent $taskContent `
                     -Question $pq -Answer $resolved.answer -Attachments $resolved.attachments -BotRoot $botRoot `
                     -Comment $comment -RankedItems $rankedItems -ReviewedAttachmentIds $reviewedIds
+                Invoke-NotificationInboundDecision -PendingQuestion $pq -Notification $notifEntry `
+                    -Resolved $resolved -TaskId $taskId -BotRoot $botRoot
 
                 # Re-read after mutation to pick up updated pending_questions for next iteration
                 if (Test-Path $taskFile.FullName) {
diff --git a/src/ui/modules/SettingsAPI.psm1 b/src/ui/modules/SettingsAPI.psm1
index 29a8bd6c..32c1a113 100644
--- a/src/ui/modules/SettingsAPI.psm1
+++ b/src/ui/modules/SettingsAPI.psm1
@@ -59,9 +59,84 @@ function Save-OverridesHashtable {
         New-Item -ItemType Directory -Path $script:Config.ControlDir -Force | Out-Null
     }
     $overridesFile = Join-Path $script:Config.ControlDir "settings.json"
+
+    # Capture the prior on-disk state BEFORE the write so the inbound decision
+    # funnel can diff old vs new (issue #416). Runs inside the settings mutex
+    # held by Invoke-SettingsFileLocked, so no extra lock is taken here.
+    $priorOverrides = $null
+    if (Test-Path $overridesFile) {
+        try { $priorOverrides = Get-Content $overridesFile -Raw | ConvertFrom-Json } catch { $priorOverrides = $null }
+    }
+
     $tmp = "$overridesFile.tmp"
     $Overrides | ConvertTo-Json -Depth 10 | Set-Content $tmp -Force -Encoding utf8NoBOM
     Move-Item -LiteralPath $tmp -Destination $overridesFile -Force
+
+    Invoke-SettingsInboundDecisions -Prior $priorOverrides -New $Overrides
+}
+
+# Flatten a settings object to a map of dotted-path -> stringified leaf value.
+# Objects recurse; arrays are treated as a single leaf (compact JSON) so that
+# file_listener.watchers compares as one value rather than per-element.
+function Get-FlatSettingLeaves {
+    param($Object, [string]$Prefix = '')
+    $leaves = @{}
+    if ($null -eq $Object) { return $leaves }
+
+    $props = @()
+    if ($Object -is [System.Collections.IDictionary]) {
+        foreach ($k in $Object.Keys) { $props += , @("$k", $Object[$k]) }
+    } elseif ($Object -is [PSCustomObject]) {
+        foreach ($p in $Object.PSObject.Properties) { $props += , @($p.Name, $p.Value) }
+    } else {
+        return $leaves
+    }
+
+    foreach ($pair in $props) {
+        $name = $pair[0]; $val = $pair[1]
+        $path = if ($Prefix) { "$Prefix.$name" } else { "$name" }
+        if ($val -is [System.Collections.IDictionary] -or $val -is [PSCustomObject]) {
+            $child = Get-FlatSettingLeaves -Object $val -Prefix $path
+            foreach ($ck in $child.Keys) { $leaves[$ck] = $child[$ck] }
+        } elseif (($val -is [System.Array]) -or ($val -is [System.Collections.IList] -and $val -isnot [string])) {
+            $leaves[$path] = ($val | ConvertTo-Json -Depth 10 -Compress)
+        } else {
+            $leaves[$path] = "$val"
+        }
+    }
+    return $leaves
+}
+
+# Best-effort: diff prior vs new settings leaves and route each changed key
+# through the inbound funnel. The funnel owns the material-key allow-list, so
+# this caller deliberately passes EVERY changed key and lets non-material keys
+# be dropped there (single vocabulary source). A failure must not fail the save.
+function Invoke-SettingsInboundDecisions {
+    param($Prior, $New)
+    try {
+        if (-not (Get-Command New-InboundDecision -ErrorAction SilentlyContinue)) {
+            Import-Module (Join-Path $PSScriptRoot ".." ".." "runtime" "Modules" "Dotbot.Decision" "Dotbot.Decision.psd1") -DisableNameChecking -Global -ErrorAction Stop
+        }
+
+        $priorLeaves = Get-FlatSettingLeaves -Object $Prior
+        $newLeaves = Get-FlatSettingLeaves -Object $New
+
+        $allKeys = @($priorLeaves.Keys) + @($newLeaves.Keys) | Select-Object -Unique
+        foreach ($key in $allKeys) {
+            $before = if ($priorLeaves.ContainsKey($key)) { $priorLeaves[$key] } else { $null }
+            $after = if ($newLeaves.ContainsKey($key)) { $newLeaves[$key] } else { $null }
+            if ("$before" -eq "$after") { continue }
+            $null = New-InboundDecision -Source settings -BotPath $script:Config.BotRoot -Payload @{
+                key    = $key
+                before = $before
+                after  = $after
+            }
+        }
+    } catch {
+        if (Get-Command Write-BotLog -ErrorAction SilentlyContinue) {
+            Write-BotLog -Level Warn -Message "Inbound decision funnel (settings) failed" -Exception $_
+        }
+    }
 }
 
 # Internal: run a script block under an OS-level named mutex keyed on the
diff --git a/tests/Test-Components.ps1 b/tests/Test-Components.ps1
index e3f1ede7..d3c29cdd 100644
--- a/tests/Test-Components.ps1
+++ b/tests/Test-Components.ps1
@@ -6869,6 +6869,210 @@ foreach ($case in $validatorCases) {
     }
 }
 
+# ═══════════════════════════════════════════════════════════════════
+# INBOUND DECISION FUNNEL (issue #416)
+# ═══════════════════════════════════════════════════════════════════
+
+Write-Host ""
+Write-Host "  INBOUND DECISION FUNNEL" -ForegroundColor Cyan
+Write-Host "  ────────────────────────────────────────────" -ForegroundColor DarkGray
+
+Import-Module (Join-Path $repoRoot "src/runtime/Modules/Dotbot.Decision/Dotbot.Decision.psd1") -Force -DisableNameChecking
+
+# Isolated .bot for funnel tests (the module accepts -BotPath to target it).
+$funnelBot = Join-Path ([System.IO.Path]::GetTempPath()) (".bot-funnel-" + [guid]::NewGuid().ToString("N").Substring(0, 8))
+New-Item -ItemType Directory -Force -Path $funnelBot | Out-Null
+
+function Get-FunnelRecord {
+    param([string]$DecisionId)
+    $decisionsDir = Join-Path $funnelBot "workspace" "decisions"
+    $file = Get-ChildItem -Path $decisionsDir -Recurse -Filter "$DecisionId*.json" -File -ErrorAction SilentlyContinue | Select-Object -First 1
+    if (-not $file) { return $null }
+    return (Get-Content $file.FullName -Raw | ConvertFrom-Json)
+}
+
+# --- One record per source, with expected type/status/impact/external_ref ---
+$mAppr = New-InboundDecision -Source mothership -BotPath $funnelBot -Payload @{
+    questionType = 'approval'; answer = 'approved'; questionText = 'Approve the plan?'
+    questionId = 'q-appr'; projectId = 'proj-1'; instanceId = 'inst-1'; taskId = 'task-1'
+}
+$mApprRec = Get-FunnelRecord -DecisionId $mAppr.decision_id
+Assert-True -Name "funnel/mothership approval writes record" -Condition ($null -ne $mApprRec)
+Assert-Equal -Name "funnel/mothership approval type" -Expected 'process' -Actual "$($mApprRec.type)"
+Assert-Equal -Name "funnel/mothership approval status accepted" -Expected 'accepted' -Actual "$($mApprRec.status)"
+Assert-Equal -Name "funnel/mothership approval impact medium" -Expected 'medium' -Actual "$($mApprRec.impact)"
+Assert-Equal -Name "funnel/mothership external_ref.source" -Expected 'mothership' -Actual "$($mApprRec.external_ref.source)"
+Assert-True -Name "funnel/mothership tags inbound:mothership" -Condition (@($mApprRec.tags) -contains 'inbound:mothership')
+
+$regAdd = New-InboundDecision -Source registry -BotPath $funnelBot -Payload @{
+    action = 'add'; namespace = 'myorg'; workflow = 'my-wf'; title = 'Adopt workflow my-wf from myorg'
+}
+$regRec = Get-FunnelRecord -DecisionId $regAdd.decision_id
+Assert-True -Name "funnel/registry add writes record" -Condition ($null -ne $regRec)
+Assert-Equal -Name "funnel/registry type process" -Expected 'process' -Actual "$($regRec.type)"
+Assert-Equal -Name "funnel/registry external_ref.source" -Expected 'registry' -Actual "$($regRec.external_ref.source)"
+Assert-True -Name "funnel/registry tags inbound:registry" -Condition (@($regRec.tags) -contains 'inbound:registry')
+
+$setProv = New-InboundDecision -Source settings -BotPath $funnelBot -Payload @{ key = 'provider'; before = 'claude'; after = 'codex' }
+$setProvRec = Get-FunnelRecord -DecisionId $setProv.decision_id
+Assert-True -Name "funnel/settings provider writes record" -Condition ($null -ne $setProvRec)
+Assert-Equal -Name "funnel/settings external_ref.source" -Expected 'settings' -Actual "$($setProvRec.external_ref.source)"
+Assert-True -Name "funnel/settings tags inbound:settings" -Condition (@($setProvRec.tags) -contains 'inbound:settings')
+
+# --- Idempotency: same key twice -> one record (cache-hit path) ---
+$dupBefore = (Get-ChildItem -Path (Join-Path $funnelBot "workspace/decisions") -Recurse -Filter '*.json' -File).Count
+$mApprDup = New-InboundDecision -Source mothership -BotPath $funnelBot -Payload @{
+    questionType = 'approval'; answer = 'approved'; questionText = 'Approve the plan?'
+    questionId = 'q-appr'; projectId = 'proj-1'; instanceId = 'inst-1'; taskId = 'task-1'
+}
+$dupAfter = (Get-ChildItem -Path (Join-Path $funnelBot "workspace/decisions") -Recurse -Filter '*.json' -File).Count
+Assert-True -Name "funnel/idempotency cache-hit returns null" -Condition ($null -eq $mApprDup)
+Assert-Equal -Name "funnel/idempotency no second record" -Expected $dupBefore -Actual $dupAfter
+
+# --- Dedup with empty cache: committed external_ref.key scan (fresh-clone) ---
+Remove-Item -Path (Join-Path $funnelBot ".control" "decisions-inbound") -Recurse -Force -ErrorAction SilentlyContinue
+$scanBefore = (Get-ChildItem -Path (Join-Path $funnelBot "workspace/decisions") -Recurse -Filter '*.json' -File).Count
+$mApprScan = New-InboundDecision -Source mothership -BotPath $funnelBot -Payload @{
+    questionType = 'approval'; answer = 'approved'; questionText = 'Approve the plan?'
+    questionId = 'q-appr'; projectId = 'proj-1'; instanceId = 'inst-1'; taskId = 'task-1'
+}
+$scanAfter = (Get-ChildItem -Path (Join-Path $funnelBot "workspace/decisions") -Recurse -Filter '*.json' -File).Count
+Assert-True -Name "funnel/dedup empty-cache scans committed records" -Condition ($null -eq $mApprScan)
+Assert-Equal -Name "funnel/dedup empty-cache no new record" -Expected $scanBefore -Actual $scanAfter
+
+# --- Non-material settings key -> no record ---
+$setNon = New-InboundDecision -Source settings -BotPath $funnelBot -Payload @{ key = 'costs.hourly_rate'; before = '50'; after = '60' }
+Assert-True -Name "funnel/settings non-material key skipped" -Condition ($null -eq $setNon)
+
+# --- Provider change and mothership.enabled both impact high ---
+$setMoth = New-InboundDecision -Source settings -BotPath $funnelBot -Payload @{ key = 'mothership.enabled'; before = 'False'; after = 'True' }
+$setMothRec = Get-FunnelRecord -DecisionId $setMoth.decision_id
+Assert-Equal -Name "funnel/settings provider impact high" -Expected 'high' -Actual "$($setProvRec.impact)"
+Assert-Equal -Name "funnel/settings mothership.enabled impact high" -Expected 'high' -Actual "$($setMothRec.impact)"
+
+# --- Free-text mothership -> proposed; approval -> accepted (already asserted) ---
+$mFree = New-InboundDecision -Source mothership -BotPath $funnelBot -Payload @{
+    questionType = 'freeText'; answer = 'some free text answer'
+    questionId = 'q-free'; projectId = 'proj-1'; instanceId = 'inst-1'; taskId = 'task-1'
+}
+$mFreeRec = Get-FunnelRecord -DecisionId $mFree.decision_id
+Assert-Equal -Name "funnel/mothership freeText status proposed" -Expected 'proposed' -Actual "$($mFreeRec.status)"
+
+# --- Option answer: bare key resolves to "<key> - <label>" + rationale ------
+$mOpt = New-InboundDecision -Source mothership -BotPath $funnelBot -Payload @{
+    questionType = ''; answer = 'C'; questionText = 'What form factor should this ship as?'
+    questionId = 'q-opt'; projectId = 'proj-1'; instanceId = 'inst-1'; taskId = 'task-1'
+    options = @(
+        @{ key = 'A'; label = 'Web app'; rationale = 'Widest reach' },
+        @{ key = 'C'; label = 'Command-line tool'; rationale = 'Developer audience, scriptable' }
+    )
+}
+$mOptRec = Get-FunnelRecord -DecisionId $mOpt.decision_id
+Assert-Equal -Name "funnel/mothership option key resolves to label" -Expected 'C - Command-line tool' -Actual "$($mOptRec.decision)"
+Assert-Equal -Name "funnel/mothership option rationale -> consequences" -Expected 'Developer audience, scriptable' -Actual "$($mOptRec.consequences)"
+Assert-True -Name "funnel/mothership context carries question text" -Condition ("$($mOptRec.context)" -like '*What form factor*')
+
+# --- Best-effort: underlying write throws -> no rethrow, returns null ---
+# Force New-DecisionRecord to fail by occupying workspace/decisions with a FILE
+# so the directory create throws; the funnel must swallow it.
+$brokenBot = Join-Path ([System.IO.Path]::GetTempPath()) (".bot-broken-" + [guid]::NewGuid().ToString("N").Substring(0, 8))
+New-Item -ItemType Directory -Force -Path (Join-Path $brokenBot "workspace") | Out-Null
+Set-Content -Path (Join-Path $brokenBot "workspace" "decisions") -Value "not a directory" -Encoding UTF8
+$threwFunnel = $false
+$bestEffortResult = $null
+try {
+    $bestEffortResult = New-InboundDecision -Source settings -BotPath $brokenBot -Payload @{ key = 'provider'; before = 'a'; after = 'b' }
+} catch {
+    $threwFunnel = $true
+}
+Assert-True -Name "funnel/best-effort does not rethrow" -Condition (-not $threwFunnel)
+Assert-True -Name "funnel/best-effort returns null on write failure" -Condition ($null -eq $bestEffortResult)
+Remove-Item -Path $brokenBot -Recurse -Force -ErrorAction SilentlyContinue
+
+Remove-Item -Path $funnelBot -Recurse -Force -ErrorAction SilentlyContinue
+
+# ═══════════════════════════════════════════════════════════════════
+# NEEDS-INPUT -> MOTHERSHIP DISPATCH HOOK (enter-needs-input)
+# ═══════════════════════════════════════════════════════════════════
+# NOTE: this block defines global stubs (Send-TaskNotification etc.) to drive
+# the hook in isolation. It is intentionally the LAST test block so those stubs
+# cannot shadow real commands used by any later test.
+
+Write-Host ""
+Write-Host "  NEEDS-INPUT DISPATCH HOOK" -ForegroundColor Cyan
+Write-Host "  ────────────────────────────────────────────" -ForegroundColor DarkGray
+
+$niHookScript = Join-Path $repoRoot "src/runtime/Plugins/Hooks/Transitions/enter-needs-input/script.ps1"
+Assert-True -Name "enter-needs-input/script exists" -Condition (Test-Path $niHookScript)
+
+# --- Discovery: the hook is registered and selected for needs-input ---
+Import-Module (Join-Path $repoRoot "src/runtime/Modules/Dotbot.Hook/Dotbot.Hook.psd1") -Force -DisableNameChecking
+$niRegistry = Get-HookRegistry -BotRoot (Join-Path ([System.IO.Path]::GetTempPath()) ("nohooks-" + [guid]::NewGuid().ToString('N').Substring(0, 6)))
+$niForStatus = @(Get-HooksForStatus -Registry $niRegistry -ToStatus 'needs-input')
+$niMeta = $niForStatus | Where-Object { $_.name -eq 'enter-needs-input' } | Select-Object -First 1
+Assert-True -Name "enter-needs-input/discovered for needs-input status" -Condition ($null -ne $niMeta)
+Assert-True -Name "enter-needs-input/is best-effort (abort_on_failure=false)" -Condition ($null -ne $niMeta -and -not [bool]$niMeta.abort_on_failure)
+
+# --- Functional: drive Invoke-Hook via New-Module (mirrors the dispatcher's isolation) ---
+function New-NiHookModule { New-Module -ScriptBlock ([scriptblock]::Create((Get-Content -LiteralPath $niHookScript -Raw))) }
+function Build-NiTask {
+    param([string]$Path)
+    $t = @{ id = 't_ni'; name = 'NI'; status = 'needs-input'; extensions = @{ runner = @{ pending_questions = @(
+        @{ id = 'q1'; question = 'Platform?'; context = 'c'; options = @(@{ key = 'A'; label = 'Web'; rationale = 'r' }); recommendation = 'A' },
+        @{ id = 'q2'; question = 'Scope?';    context = 'c'; options = @(@{ key = 'A'; label = 'Sci'; rationale = 'r' }); recommendation = 'A' }
+    ) } } }
+    $t | ConvertTo-Json -Depth 20 | Set-Content -LiteralPath $Path -Encoding UTF8
+    return $t
+}
+
+$env:DOTBOT_HOME = $repoRoot
+function global:Write-BotLog { param($Level, $Message, $Exception) }
+function global:Write-TaskFileAtomic { param($Path, $Content, $Depth = 20, $TaskId, $BotRoot) $Content | ConvertTo-Json -Depth $Depth | Set-Content -LiteralPath $Path -Encoding UTF8 }
+function global:Get-NotificationSettings { param($BotRoot) [pscustomobject]@{ enabled = $true; channel = 'teams' } }
+function global:Send-TaskNotification { param($TaskContent, $PendingQuestion, $Settings, $Type)
+    @{ success = $true; question_id = "qid-$($PendingQuestion.id)"; instance_id = "inst-$($PendingQuestion.id)"; project_id = 'proj'; channel = 'teams' } }
+
+$niTmp = Join-Path ([System.IO.Path]::GetTempPath()) ("nihook-" + [guid]::NewGuid().ToString('N').Substring(0, 8))
+New-Item -ItemType Directory -Force -Path $niTmp | Out-Null
+$niBot = Join-Path $niTmp '.bot'; New-Item -ItemType Directory -Force -Path $niBot | Out-Null
+
+# Case 1: enabled + batch -> notifications map keyed by pending_questions ids
+$niTf = Join-Path $niTmp 't_ni.json'
+$niTask = Build-NiTask -Path $niTf
+$niRes = & (New-NiHookModule) Invoke-Hook -Task $niTask -RunContext @{ BotRoot = $niBot; TaskPath = $niTf } -FromStatus 'in-progress' -ToStatus 'needs-input'
+Assert-True -Name "enter-needs-input/enabled batch returns Success" -Condition ([bool]$niRes.Success)
+$niWritten = Get-Content $niTf -Raw | ConvertFrom-Json
+$niMap = $niWritten.extensions.runner.notifications
+Assert-True -Name "enter-needs-input/writes notifications map keyed by question ids" `
+    -Condition ($null -ne $niMap -and $null -ne $niMap.q1 -and $null -ne $niMap.q2)
+Assert-Equal -Name "enter-needs-input/map entry has question_id" -Expected 'qid-q1' -Actual "$($niMap.q1.question_id)"
+Assert-Equal -Name "enter-needs-input/map entry has instance_id" -Expected 'inst-q1' -Actual "$($niMap.q1.instance_id)"
+Assert-Equal -Name "enter-needs-input/map entry has project_id" -Expected 'proj' -Actual "$($niMap.q1.project_id)"
+
+# Case 2: disabled -> no map, still Success
+function global:Get-NotificationSettings { param($BotRoot) [pscustomobject]@{ enabled = $false } }
+$niTf2 = Join-Path $niTmp 't_ni2.json'
+$niTask2 = Build-NiTask -Path $niTf2
+$niRes2 = & (New-NiHookModule) Invoke-Hook -Task $niTask2 -RunContext @{ BotRoot = $niBot; TaskPath = $niTf2 } -FromStatus 'in-progress' -ToStatus 'needs-input'
+$niWritten2 = Get-Content $niTf2 -Raw | ConvertFrom-Json
+Assert-True -Name "enter-needs-input/disabled returns Success" -Condition ([bool]$niRes2.Success)
+Assert-True -Name "enter-needs-input/disabled writes no notifications map" `
+    -Condition (-not [bool]$niWritten2.extensions.runner.PSObject.Properties['notifications'])
+
+# Case 3: send throws -> best-effort, no rethrow, still Success
+function global:Get-NotificationSettings { param($BotRoot) [pscustomobject]@{ enabled = $true } }
+function global:Send-TaskNotification { param($TaskContent, $PendingQuestion, $Settings, $Type) throw "boom" }
+$niTf3 = Join-Path $niTmp 't_ni3.json'
+$niTask3 = Build-NiTask -Path $niTf3
+$niThrew = $false
+$niRes3 = $null
+try { $niRes3 = & (New-NiHookModule) Invoke-Hook -Task $niTask3 -RunContext @{ BotRoot = $niBot; TaskPath = $niTf3 } -FromStatus 'in-progress' -ToStatus 'needs-input' } catch { $niThrew = $true }
+Assert-True -Name "enter-needs-input/send failure does not rethrow" -Condition (-not $niThrew)
+Assert-True -Name "enter-needs-input/send failure still returns Success" -Condition ($null -ne $niRes3 -and [bool]$niRes3.Success)
+
+Remove-Item Function:\global:Send-TaskNotification, Function:\global:Get-NotificationSettings, Function:\global:Write-TaskFileAtomic, Function:\global:Write-BotLog -ErrorAction SilentlyContinue
+Remove-Item -Path $niTmp -Recurse -Force -ErrorAction SilentlyContinue
+
 # ═══════════════════════════════════════════════════════════════════
 # CLEANUP
 # ═══════════════════════════════════════════════════════════════════
diff --git a/tests/Test-WorkflowManifest.ps1 b/tests/Test-WorkflowManifest.ps1
index 12d59145..d06caef1 100644
--- a/tests/Test-WorkflowManifest.ps1
+++ b/tests/Test-WorkflowManifest.ps1
@@ -1682,8 +1682,7 @@ Assert-True -Name "Fix#1: Test-ManifestCondition visible after nested import of
 # select: query rather than broadening when the MCP server is still warming up.
 $promptFiles = @(
     (Join-Path $repoRoot "content\workflows\start-from-prompt\prompts\03b-expand-task-group.md"),
-    (Join-Path $repoRoot "content\workflows\start-from-prompt\prompts\01b-generate-decisions.md"),
-    (Join-Path $repoRoot "content/prompts/98-analyse-task.md")
+    (Join-Path $repoRoot "content\workflows\start-from-prompt\prompts\01b-generate-decisions.md")
 )
 foreach ($pf in $promptFiles) {
     $relName = Split-Path $pf -Leaf
@@ -1705,34 +1704,21 @@ Assert-True -Name "Fix#4: 01b-generate-decisions.md marks interview-summary.md a
 Assert-True -Name "Fix#4: 01b-generate-decisions.md still reads mission/tech-stack/entity-model unconditionally" `
     -Condition (($decisionsPromptSrc -match 'mission\.md') -and ($decisionsPromptSrc -match 'tech-stack\.md') -and ($decisionsPromptSrc -match 'entity-model\.md'))
 
-# ── Batch 2, Fix A: 99-autonomous-task.md must teach agents branch-conditional
-# push semantics so tasks that run on shared branches (main/master) are
-# pushed immediately instead of leaving the agent stuck on the
-# 02-git-pushed.ps1 gate at task_mark_done time.
-$autonomousTaskPrompts = @(
-    (Join-Path $repoRoot "content/prompts/99-autonomous-task.md"),
-    (Join-Path $repoRoot "content/workflows/start-from-jira/prompts/99-autonomous-task.md")
-)
-foreach ($pf in $autonomousTaskPrompts) {
-    $relName = Split-Path $pf -Leaf
-    # Label the prompt by its top-level source — "core" for the framework copy,
-    # the workflow name for workflow-scoped overrides.
-    $parentDir = if ($pf -match '[/\\]core[/\\]prompts[/\\]') {
-        'core'
-    } else {
-        Split-Path (Split-Path (Split-Path (Split-Path $pf -Parent) -Parent) -Parent) -Leaf
-    }
-    Assert-PathExists -Name "Fix#A: $parentDir/$relName exists" -Path $pf
-    $src = Get-Content $pf -Raw
-    Assert-True -Name "Fix#A: $parentDir/$relName assumes a task worktree" `
-        -Condition ($src -match 'task\s+worktree')
-    Assert-True -Name "Fix#A: $parentDir/$relName tells agents not to push" `
-        -Condition ($src -match 'do\s+not\s+push')
-    Assert-True -Name "Fix#A: $parentDir/$relName no longer has shared-branch fallback instructions" `
-        -Condition (-not ($src -match 'shared\s+branch|push\s+immediately|02-git-pushed\.ps1'))
-    Assert-True -Name "Fix#A: $parentDir/$relName no longer hardcodes old bold worktree assertion" `
-        -Condition (-not ($src -match 'You are working in a \*\*git worktree\*\* on branch'))
-}
+# ── Batch 2, Fix A: 100-single-session-task.md must assume a task worktree and
+# tell agents not to push (the framework squash-merges the task branch), with
+# no leftover shared-branch fallback that would strand the agent on the
+# 02-git-pushed.ps1 gate at task-completion time.
+$singleSessionPromptPath = Join-Path $repoRoot "content/prompts/100-single-session-task.md"
+Assert-PathExists -Name "Fix#A: 100-single-session-task.md exists" -Path $singleSessionPromptPath
+$singleSessionSrc = Get-Content $singleSessionPromptPath -Raw
+Assert-True -Name "Fix#A: 100-single-session-task.md assumes a task worktree" `
+    -Condition ($singleSessionSrc -match 'task\s+worktree')
+Assert-True -Name "Fix#A: 100-single-session-task.md tells agents not to push" `
+    -Condition ($singleSessionSrc -match 'do\s+not\s+push')
+Assert-True -Name "Fix#A: 100-single-session-task.md has no shared-branch fallback instructions" `
+    -Condition (-not ($singleSessionSrc -match 'shared\s+branch|push\s+immediately|02-git-pushed\.ps1'))
+Assert-True -Name "Fix#A: 100-single-session-task.md no longer hardcodes old bold worktree assertion" `
+    -Condition (-not ($singleSessionSrc -match 'You are working in a \*\*git worktree\*\* on branch'))
 
 # ── Batch 2, Fix B: 03a-plan-task-groups.md must include task-level rigor
 # (schema, acceptance-criteria quality bar, effort sizing, dependency chain)
@@ -1766,36 +1752,11 @@ Assert-True -Name "Fix#B: 03b cross-links to 03a for schema/criteria/sizing" `
 Assert-True -Name "Fix#B: 03b tells agent not to relax constraints during expansion" `
     -Condition ($expandTaskGroupSrc -match 'do\s+not\s+relax\s+them\s+during\s+expansion')
 
-# ── Batch 2, Fix C: 98-analyse-task.md must guard mission/tech-stack/entity-model
-# reads against the current task's outputs list, so tasks that produce those
-# files (e.g. workflow Product Documents) do not error during pre-flight
-# analysis trying to read files they are supposed to create.
-$analyseTaskPath = Join-Path $repoRoot "content/prompts/98-analyse-task.md"
-Assert-PathExists -Name "Fix#C: 98-analyse-task.md exists" -Path $analyseTaskPath
-$analyseTaskSrc = Get-Content $analyseTaskPath -Raw
-Assert-True -Name "Fix#C: 98-analyse-task.md has skip-if-produced guard in Phase 2" `
-    -Condition ($analyseTaskSrc -match '(?s)Phase\s+2:\s+Entity\s+Detection.*?Skip-if-produced\s+guard')
-Assert-True -Name "Fix#C: 98-analyse-task.md has skip-if-produced guard in Phase 6" `
-    -Condition ($analyseTaskSrc -match '(?s)Phase\s+6:\s+Product\s+Context\s+Extraction.*?Skip-if-produced\s+guard')
-Assert-True -Name "Fix#C: 98-analyse-task.md entity-model read is marked skip-if-outputs" `
-    -Condition ($analyseTaskSrc -match 'Read\s+entity\s+model[^\r\n]*skip\s+if\s+in\s+task\s+`outputs`')
-Assert-True -Name "Fix#C: 98-analyse-task.md mission read is marked skip-if-outputs" `
-    -Condition ($analyseTaskSrc -match 'Read\s+mission[^\r\n]*skip\s+if\s+in\s+task\s+`outputs`')
-Assert-True -Name "Fix#C: 98-analyse-task.md refers to task outputs list for the guard" `
-    -Condition ($analyseTaskSrc -match "task's\s+``outputs``\s+list")
-
-# ── #365: 98-analyse-task.md must not probe .bot/recipes/standards/global with
-# a Glob, and 99-autonomous-task.md must not list it as a context-file source.
-# The prompt now relies on {{APPLICABLE_STANDARDS}} plus the task's
-# `applicable_standards` list. Both checks must hold even if a future edit
-# reorders the Glob keys or splits the call across lines.
-Assert-True -Name "#365: 98-analyse-task.md no longer issues a Glob over .bot/recipes/standards/global" `
-    -Condition (-not ($analyseTaskSrc -match '(?s)Glob\([^)]*\.bot/recipes/standards/global'))
-Assert-True -Name "#365: 98-analyse-task.md tells the agent not to probe .bot/recipes/standards/global" `
-    -Condition ($analyseTaskSrc -match 'Do\s+not\s+probe\s+`\.bot/recipes/standards/global/`')
-
-$execPromptSrc = Get-Content (Join-Path $repoRoot "content/prompts/99-autonomous-task.md") -Raw
-Assert-True -Name "#365: 99-autonomous-task.md no longer cites .bot/recipes/standards/global/*.md as a context file" `
+# ── #365: 100-single-session-task.md must not list .bot/recipes/standards/global
+# as a context-file source. The prompt now relies on {{APPLICABLE_STANDARDS}}
+# plus the task's `applicable_standards` list.
+$execPromptSrc = Get-Content (Join-Path $repoRoot "content/prompts/100-single-session-task.md") -Raw
+Assert-True -Name "#365: 100-single-session-task.md no longer cites .bot/recipes/standards/global/*.md as a context file" `
     -Condition (-not ($execPromptSrc -match '\.bot/recipes/standards/global/\*\.md'))
 
 # Runtime fallback must not push agents back toward the directory the prompts
@@ -1886,13 +1847,12 @@ Assert-True -Name "Fix#H: 03a example task-groups.json includes applicable_decis
 Assert-True -Name "Fix#H: 03a Field Reference declares applicable_decisions as a required field" `
     -Condition ($planTaskGroupsSrc -match '\|\s+`applicable_decisions`\s+\|\s+Yes\s+\|')
 
-# ── #364: Both core prompts must warn that the Bash tool runs Bash, not
+# ── #364: The live task prompt must warn that the Bash tool runs Bash, not
 # PowerShell. Agents picked up PowerShell's $obj.property syntax from the
 # project's PowerShell-heavy code and got `extglob.project_name: command not
 # found` errors when piping JSON through Bash.
 $bashWarningPrompts = @(
-    (Join-Path $repoRoot "content/prompts/99-autonomous-task.md"),
-    (Join-Path $repoRoot "content/prompts/98-analyse-task.md")
+    (Join-Path $repoRoot "content/prompts/100-single-session-task.md")
 )
 foreach ($pf in $bashWarningPrompts) {
     $relName = Split-Path $pf -Leaf