diff --git a/.claude/commands/ingest-review.md b/.claude/commands/ingest-review.md
index 14f3dc0..3f7f0a4 100644
--- a/.claude/commands/ingest-review.md
+++ b/.claude/commands/ingest-review.md
@@ -11,33 +11,70 @@ outputs:
 
 # Ingest PR Review Feedback
 
-Process review comments from a merged PR and update agent memory.
+Parse structured review findings from TaskRun records and update agent memory.
 
 ## Instructions
 
 1. Get the PR number from `$ARGUMENTS`. If empty, ask the user.
 
-2. Fetch PR data:
+2. Query the database for reviewer TaskRun records linked to this PR:
    ```bash
-   gh pr view <PR_NUMBER> --json comments,reviews,body,title
-   gh api repos/<OWNER>/<REPO>/pulls/<PR_NUMBER>/comments
+   # Find the reviewer run's handoff data
+   python3 -c "
+   import asyncio, json, os
+   os.environ.setdefault('SOVA_DATABASE_URL', 'sqlite+aiosqlite://.claude/sova.db')
+   from sova.db.session import init_db, get_session
+   from sova.db.models import TaskRun
+   from sqlalchemy import select
+
+   async def main():
+       await init_db(run_migrations=False)
+       async with get_session() as session:
+           stmt = select(TaskRun).where(
+               TaskRun.pr_number == <PR_NUMBER>,
+               TaskRun.role.in_(['reviewer', 'command:review-pr']),
+               TaskRun.status == 'done',
+           ).order_by(TaskRun.id.desc()).limit(1)
+           run = (await session.execute(stmt)).scalar_one_or_none()
+           if not run or not run.handoff_json:
+               print('NO_FINDINGS')
+               return
+           print(json.dumps(run.handoff_json, indent=2))
+
+   asyncio.run(main())
+   "
+   ```
+
+3. If the output is `NO_FINDINGS`, report "No reviewer findings found for PR #N" and stop.
+
+4. Parse the `pending_findings` array from the handoff JSON. Each finding has:
+   - `file`: file path
+   - `line`: line number
+   - `severity`: 1-10 score
+   - `category`: type of issue (bug, style, performance, etc.)
+   - `description`: what the issue is
+   - `suggestion`: how to fix it
+
+5. Also fetch external review comments (CodeRabbit, human reviewers):
+   ```bash
+   gh pr view <PR_NUMBER> --json reviews,comments --jq '.reviews[] | {author: .author.login, state: .state, body: .body}'
    ```
 
-3. Analyze review comments and extract lessons:
-   - **Patterns to always follow** -- things reviewers praised or requested
-   - **Mistakes to avoid** -- bugs caught, missing edge cases, style violations
-   - **Style preferences** -- formatting, naming, structural preferences
-   - **Test coverage gaps** -- missing assertions, untested scenarios
+6. Classify findings into memory categories:
+   - **Severity >= 7**: likely a "common_mistake" -- check `.claude/agent-memory/cookbook.md` for existing entries
+   - **Severity 4-6 with "style" or "naming" category**: "style preference"
+   - **Repeated patterns across findings**: "review pattern" worth codifying
+   - **Test-related findings**: "test coverage gap"
 
-4. Read existing memory file:
+7. Read existing memory file:
    - `.claude/agent-memory/cookbook.md`
 
-5. Update `.claude/agent-memory/cookbook.md`:
+8. Update `.claude/agent-memory/cookbook.md`:
    - Append new findings under the matching domain section (no duplicates)
-   - If a mistake has appeared before, add it to the "Common Mistakes" section with `[Nx]` count
-   - If a finding is high-impact, add it to `MEMORY.md`
+   - If a mistake already exists, increment its `[Nx]` count
+   - If a finding is high-impact (severity >= 8), also add it to `.claude/agent-memory/MEMORY.md`
 
-6. Report what was learned and which files were updated.
+9. Report what was learned and which files were updated.
 
 ## Cross-References
 
@@ -47,4 +84,5 @@ Process review comments from a merged PR and update agent memory.
 ## Rules
 
 - Only record actionable, specific lessons -- not generic advice
+- Parse structured data from DB records; do NOT use LLM summarization
 - NEVER use emojis in any output
diff --git a/.claude/rules/architecture.md b/.claude/rules/architecture.md
index 8b301e3..888022e 100644
--- a/.claude/rules/architecture.md
+++ b/.claude/rules/architecture.md
@@ -14,7 +14,7 @@ SOVA has four main components:
 - `core/state.py` -- 17-state TaskStatus StrEnum with transition validation
 - `core/context.py` -- ExecutionContext dataclass threading state through steps
 - `core/output.py` -- OutputWriter for per-run DB-backed output persistence, read_lines, retention cleanup
-- `core/steps/` -- 29 BaseStep implementations with execute/validate_output/can_skip. Four pipeline variants:
+- `core/steps/` -- 26 BaseStep implementations with execute/validate_output/can_skip. Four pipeline variants:
   - **Developer pipeline** (16 steps): sync -> assess -> create_worktree -> capture_baseline -> develop -> simplify -> self_review -> commit -> validate -> push -> create_pr -> wait_for_external_reviews -> address_external_findings -> monitor_ci -> extract_memory -> handoff_to_reviewer
   - **Address-review pipeline** (9 steps): rebase -> address_review -> commit -> validate -> push -> monitor_ci -> resolve_external_reviews -> extract_memory -> handoff_to_user
   - **Researcher pipeline** (4 steps): fetch_task -> research -> spec -> extract_memory
@@ -115,12 +115,12 @@ The project's full name is **SOVA** (Software Orchestration Via Agents).
 - **Auto-handoff must clear handoff file before spawning next agent**: `_process_auto_handoff()` in `agent_handoff.py` calls `handoff_service.clear_handoff()` before spawning the next agent via `start_agent()` or `start_command()`. Without this, the newly spawned agent or a concurrent dashboard poll may re-process the same handoff, leading to duplicate agent spawns. The clear must happen synchronously before the spawn call, not after.
 - **Seed cross-agent data before clearing the handoff file**: when spawning an agent that needs data from the previous agent's handoff (e.g., review findings for address-review), extract the data before `clear_handoff()` and write it to the new TaskRun's `handoff_json` via `start_agent(handoff_findings=...)`. Without this, the address-review step can't find findings when: (1) the handoff file was cleared, (2) `resume_run_id` points to a non-reviewer run, and (3) the issue-level DB fallback fails. File: `sova/dashboard/services/agent_db.py:_seed_handoff_findings()`.
 - **Adapter ABC contract**: `TaskAdapter` in `sova/adapters/base.py` defines 18 abstract methods: `list_tasks`, `get_task`, `get_state`, `transition_state`, `assign`, `add_label`, `remove_label`, `_do_post_comment`, `_do_post_pr_comment`, `_do_post_pr_review`, `_do_edit_body`, `link_pr`, `get_pr_reviews`, `_do_create_issue`, `get_available_transitions`, `list_milestones`, `create_milestone`, `set_milestone`, plus `github_user` field (constructor param). Public posting methods (`post_comment`, `post_pr_comment`, `post_pr_review`, `edit_body`, `create_issue`) are concrete Template Methods that run the egress filter before delegating to `_do_*` implementations. When adding new agent capabilities that interact with the tracker, add the method to the ABC first, then implement in `GitHubAdapter`. Factory: `create_adapter(type, repo, github_user, project_number)`.
-- **LLM for user-facing outputs with structured fallback**: workflow steps producing user-facing content (PR descriptions, review comments) use a focused LLM call (Sonnet, ~$0.01) with structured context (commit log, diff stats, issue body). Fallback MUST preserve available data -- build a structured body from already-fetched data rather than discarding to a bare stub. Pattern: `_generate_pr_body()` + `_build_fallback_body()` in `create_pr.py`, `_run_review()` in `reviewer.py`.
+- **Deterministic PR body from structured data**: `CreatePRStep._build_pr_body()` builds PR descriptions deterministically from commits, diff stats, issue body excerpt (truncated to 500 chars), and Closes link -- no LLM call. The reviewer role's `_run_review()` is the only user-facing LLM call in the pipeline (structured output at the right abstraction level).
 - **Rebase with LLM conflict resolution**: `rebase_with_conflict_resolution()` in `sova/git/rebase.py` rebases onto the latest base branch and uses the LLM to resolve merge conflicts. Loop: detect conflicted files, invoke LLM to fix markers + `git add`, `git rebase --continue`. Aborts on LLM failure or after `max_attempts` (default 3) so the worktree is never left in a broken rebase state. `RebaseStep` in the address-review pipeline runs this before `AddressReviewStep`. `PushStep` uses `--force-with-lease` when `ctx.pr_number` is set (post-rebase history rewrite).
 - **Pydantic request models must be at module scope in `app.py`**: `from __future__ import annotations` makes all type annotations lazy strings. FastAPI resolves annotation strings by searching the module's global namespace. Pydantic `BaseModel` subclasses defined inside nested functions (e.g., `_setup_multi_project()`) are not in module globals, so FastAPI falls back to treating the parameter as a query param, producing 422 errors. Always define request/response models at module level. File: `sova/dashboard/app.py`.
 - **Thin re-export wrappers during module splits**: when splitting a large module into submodules (e.g., `control_service.py` -> `agent_lifecycle.py` + `agent_output.py` + `agent_recovery.py`), convert the original module to a thin re-export facade (`from agent_lifecycle import X`) rather than deleting it. This preserves backward compatibility for all existing imports in routers, tests, and commands. Delete the old module only after all imports are migrated.
 - **Never non-visible overflow on containers with popout children**: the sidebar `<nav>` and its scrollable child div contain absolutely-positioned children (notification panel, CSS hover tooltips) that extend beyond their boundary at `left: 100%`. ANY non-visible overflow value (`hidden`, `auto`, `scroll`) on ANY ancestor creates a clipping boundary for positioned descendants. CSS spec: when one axis is non-visible, the other is computed to `auto` even if explicitly set to `visible` -- so `overflow-y: auto; overflow-x: visible` does NOT work (x becomes `auto` too). Use `max-width` and opacity transitions on individual child elements instead of overflow on the container. This applies to any fixed-position sidebar or panel that contains popout menus or tooltips.
-- **Automatic memory extraction**: `ExtractMemoryStep` runs before every handoff step in both pipelines. `ReviewerRole.execute()` calls `extract_memories()` directly (reviewer doesn't use WorkflowEngine). A single Haiku LLM call (~$0.005-0.01) extracts 0-5 reusable learnings from run context (role, task, files changed, step summaries, review findings). Results are stored to the Memory DB table via `memory.store()` with deduplication (title similarity check against existing memories in same category). Confirmation counters (`[confirmed: N]` in content field) track reuse; memories auto-promote to "shared" tier at N=3. Extraction is fully non-fatal: failures are logged but never block the pipeline. Module: `sova/knowledge/extraction.py`.
+- **Memory extraction is a no-op**: `ExtractMemoryStep` still runs before every handoff step in both pipelines (step slot preserved for future rule-based extraction), but `extract_memories()` returns immediately without calling the LLM. `ReviewerRole._extract_review_memories()` is also a no-op. Use the human-reviewed `/extract-knowledge` command for knowledge capture. Infrastructure (`_build_extraction_prompt`, `_parse_extraction_response`, `_deduplicate_and_store`) is retained in `sova/knowledge/extraction.py` for future use.
 - **Issue Lifecycle Control**: `IssueLifecycle` is the "spine" connecting all `TaskRun` records for a single issue into a unified journey with 6 phases (`LifecyclePhase` enum: development, post_pr, review, address_review, integrate, post_merge). `LifecyclePhaseRecord` tracks each phase execution (status, cost, attempt counter, linked TaskRun). Phase transitions are advisory (warnings, not strict enforcement) -- matches `--force` philosophy. The `post_pr` phase is passive (no TaskRun; inferred from PR creation). `lifecycle_service.py` provides CRUD, phase transitions, and backward-compatible reconstruction from pre-existing TaskRuns via `build_lifecycle_view()`. Integration hooks in `agent_lifecycle.py` (`_link_run_to_lifecycle`, `_finalize_lifecycle_phase`) are non-fatal side effects. Dashboard UI at `/lifecycle/{issue_number}` shows a phase rail with live polling.
 - **Doc counts drift after refactors**: step count, service count, adapter method count, CLI subcommand list, and test count go stale after module splits, service extractions, or ABC changes. After any structural refactor, run actual counts (`find`, `grep -c`, `wc -l`) and update AGENTS.md, architecture.md, and CLAUDE.md. The `/review` command checks doc freshness automatically.
 - **Stale references persist after file/feature renames**: when a file is deleted, renamed, or a concept changes (e.g., "PAK" -> "SOVA"), references survive in commands, rules, issue bodies, and vision docs. After any rename or deletion, run `grep -rn "OLD_NAME" . --include="*.md"` to find stale references across all markdown files. Also check GitHub Issues and VISION.md for outdated naming.
diff --git a/AGENTS.md b/AGENTS.md
index 9cb2c85..607c015 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -60,7 +60,7 @@ sova/
     KNOWLEDGE.md                   # 4-tier knowledge management system
   templates/                       # Project scaffolding templates
   deploy/                          # systemd + launchd service files
-  tests/                           # pytest suite (2800+ tests)
+  tests/                           # pytest suite (2900+ tests)
   docs/
     VISION.md                      # Product vision and roadmap
     ARCHITECTURE.md                # Architecture overview (points to .claude/rules/)
diff --git a/docs/error-handling-guidelines.md b/docs/error-handling-guidelines.md
index 52fcf97..9606e1a 100644
--- a/docs/error-handling-guidelines.md
+++ b/docs/error-handling-guidelines.md
@@ -180,13 +180,15 @@ Status updates are conditional (once terminal, never overwrite); cost updates ar
 
 When LLM calls fail for user-facing outputs, always provide a structured fallback from available data. **Never discard to a bare stub.**
 
+PR body generation uses a deterministic template (`_build_pr_body()`) -- no LLM call. For steps that still use conditional LLM calls (validate, monitor_ci, rebase), the pattern is:
+
 ```python
 try:
-    result = await invoke(prompt, model="sonnet", cwd=ctx.working_dir, timeout=120)
+    result = await invoke(prompt, model=model, cwd=ctx.working_dir, timeout=120)
     return result.text
 except RuntimeError:
-    log.warning("step.create_pr.body_generation_failed", fallback="structured")
-    return self._build_fallback_body(ctx, task_title, commit_log, diff_stat)
+    log.warning("step.operation_failed", fallback="structured")
+    return build_structured_fallback(available_data)
 ```
 
 ### JSON Parsing with Substring Extraction
diff --git a/docs/pipeline-determinism.html b/docs/pipeline-determinism.html
index 15cb64e..738879c 100644
--- a/docs/pipeline-determinism.html
+++ b/docs/pipeline-determinism.html
@@ -782,10 +782,10 @@ <h2>Determinism Opportunities</h2>
       </tr>
       <tr>
         <td>PR body generation</td>
-        <td><span class="step-tag tag-llm" style="display:inline">llm</span></td>
+        <td><span class="step-tag tag-code" style="display:inline">code</span></td>
         <td class="arrow">--></td>
         <td><span class="step-tag tag-code" style="display:inline">code</span></td>
-        <td>Structured template from commits + diff stats + issue body. Fallback already exists in <code>_build_fallback_body()</code>; promote it to primary.</td>
+        <td>Deterministic template via <code>_build_pr_body()</code>: commits + diff stats + issue body excerpt (500 char limit). Done.</td>
       </tr>
       <tr>
         <td>Commit message (step 7)</td>
diff --git a/sova/core/steps/create_pr.py b/sova/core/steps/create_pr.py
index 3c82d32..a7eec2b 100644
--- a/sova/core/steps/create_pr.py
+++ b/sova/core/steps/create_pr.py
@@ -1,4 +1,4 @@
-"""Step 9: Create PR -- generate a rich description and open a pull request."""
+"""Step 9: Create PR -- generate a structured description and open a pull request."""
 
 from __future__ import annotations
 
@@ -9,7 +9,7 @@
 from sova.core.context import ExecutionContext
 from sova.core.steps.base import BaseStep, GateCheckResult, StepResult
 from sova.git import operations as git_ops
-from sova.llm.client import invoke
+from sova.utils.formatting import truncate
 from sova.utils.logging import get_logger
 from sova.utils.shell import run
 
@@ -17,53 +17,14 @@
 
 _PLACEHOLDER = "(none)"
 
+_ISSUE_BODY_EXCERPT_LIMIT = 500
+
 _CONVENTIONAL_RE = re.compile(
     r"^(feat|fix|refactor|test|docs|chore|ci)"
     r"(?:\([^)]*\))?"
     r":\s*",
 )
 
-_PR_BODY_PROMPT_BASE = """\
-Generate a pull request description for the changes below. Output ONLY the \
-markdown body (no fences, no commentary). Use this structure:
-
-## Summary
-1-3 bullet points: WHAT changed and WHY.
-
-## Changes
-Brief description of each logical change grouped by area.
-
-## Review guidance
-What should a reviewer focus on? Any trade-offs or shortcuts?
-
-## Test plan
-How were these changes verified?
-"""
-
-_PR_BODY_ISSUE_SECTION = """
-Closes #{issue_number}
-
----
-Issue #{issue_number}: {issue_title}
-
-{issue_body}
-
-"""
-
-_PR_BODY_NO_ISSUE_SECTION = """
----
-Task: {issue_title}
-
-"""
-
-_PR_BODY_CONTEXT = """\
-Commits on this branch:
-{commit_log}
-
-Files changed:
-{diff_stat}
-"""
-
 
 def _build_pr_title(task_title: str, issue_number: str | None) -> str:
     """Build a PR title from the task title, avoiding double conventional prefixes.
@@ -169,41 +130,12 @@ async def _generate_pr_body(self, ctx: ExecutionContext, task_title: str) -> str
             ),
         )
 
-        issue_body = ctx.task.body if ctx.task else ""
         commit_log = log_result.stdout.strip() if log_result.success else "(unavailable)"
         diff_stat = diff_result.stdout.strip() if diff_result.success else "(unavailable)"
-
-        if ctx.has_issue:
-            middle = _PR_BODY_ISSUE_SECTION.format(
-                issue_number=ctx.issue_number,
-                issue_title=task_title,
-                issue_body=issue_body or "(no description)",
-            )
-        else:
-            middle = _PR_BODY_NO_ISSUE_SECTION.format(issue_title=task_title)
-
-        prompt = (
-            _PR_BODY_PROMPT_BASE
-            + middle
-            + _PR_BODY_CONTEXT.format(
-                commit_log=commit_log,
-                diff_stat=diff_stat,
-            )
-        )
-
-        try:
-            result = await invoke(prompt, model="sonnet", cwd=ctx.working_dir, timeout=120)
-            ctx.add_cost(result.cost_usd)
-            body = result.text
-            if ctx.has_issue and f"#{ctx.issue_number}" not in body:
-                body += f"\n\nCloses #{ctx.issue_number}"
-            return body
-        except RuntimeError:
-            log.warning("step.create_pr.body_generation_failed", fallback="structured")
-            return self._build_fallback_body(ctx, task_title, commit_log, diff_stat)
+        return self._build_pr_body(ctx, task_title, commit_log, diff_stat)
 
     @staticmethod
-    def _build_fallback_body(ctx: ExecutionContext, task_title: str, commit_log: str, diff_stat: str) -> str:
+    def _build_pr_body(ctx: ExecutionContext, task_title: str, commit_log: str, diff_stat: str) -> str:
         lines = [
             "## Summary",
             "",
@@ -213,6 +145,13 @@ def _build_fallback_body(ctx: ExecutionContext, task_title: str, commit_log: str
         if ctx.has_issue:
             lines.append(f"Closes #{ctx.issue_number}")
             lines.append("")
+
+        issue_body = (ctx.task.body if ctx.task else "") or ""
+        stripped_body = issue_body.strip()
+        if stripped_body:
+            excerpt = truncate(stripped_body, max_length=_ISSUE_BODY_EXCERPT_LIMIT)
+            lines.extend(["## Context", "", excerpt, ""])
+
         lines.extend(
             [
                 "## Commits",
diff --git a/sova/knowledge/extraction.py b/sova/knowledge/extraction.py
index 57ba8d7..dfd3d88 100644
--- a/sova/knowledge/extraction.py
+++ b/sova/knowledge/extraction.py
@@ -1,8 +1,9 @@
-"""Automatic memory extraction from agent runs.
+"""Memory extraction infrastructure for agent runs.
 
-Extracts reusable learnings from an agent's completed run context via a
-single LLM call (Haiku). Stores results to the Memory DB table with
-deduplication and confirmation counter tracking.
+Automatic LLM-based extraction is disabled (no-op). The infrastructure
+functions (_build_extraction_prompt, _parse_extraction_response,
+_deduplicate_and_store) are retained for future rule-based extraction.
+Use ``/extract-knowledge`` for human-reviewed knowledge capture.
 """
 
 from __future__ import annotations
@@ -16,7 +17,6 @@
 from sova.knowledge import memory
 from sova.knowledge.embeddings import embed_text
 from sova.knowledge.similarity import parse_confirmation_counter, set_confirmation_counter, titles_match
-from sova.llm.client import invoke
 from sova.utils.logging import get_logger
 
 log = get_logger(component="knowledge.extraction")
@@ -46,7 +46,7 @@ class ExtractionResult:
     error: str | None = None
 
 
-async def extract_memories(
+async def extract_memories(  # noqa: RUF029 -- async retained for caller compatibility
     *,
     role: str,
     issue_number: str,
@@ -58,54 +58,18 @@ async def extract_memories(
     spec_content: str | None = None,
     cwd: Path | str,
 ) -> ExtractionResult:
-    """Extract reusable learnings from a completed agent run.
+    """No-op: automatic memory extraction is disabled.
 
-    Makes a single Haiku LLM call to analyze the run context, then stores
-    any novel learnings to the Memory DB. Non-fatal: never raises.
-    """
-    result = ExtractionResult()
-
-    try:
-        prompt = _build_extraction_prompt(
-            role=role,
-            task_title=task_title,
-            files_changed=files_changed,
-            step_summaries=step_summaries,
-            review_findings=review_findings,
-            spec_content=spec_content,
-        )
+    LLM-based extraction had low signal-to-noise. Use the human-reviewed
+    ``/extract-knowledge`` command instead. The step slot is kept in
+    pipelines so future rule-based extraction is a single-file change.
 
-        llm_result = await invoke(prompt, model="haiku", cwd=cwd, timeout=60)
-        result.cost_usd = llm_result.cost_usd
-
-        memories = _parse_extraction_response(llm_result.text)
-        if not memories:
-            log.info("extraction.no_learnings", role=role, issue=issue_number)
-            return result
-
-        for mem in memories:
-            outcome = await _deduplicate_and_store(mem, repo=repo, issue_number=issue_number)
-            if outcome == "stored":
-                result.memories_stored += 1
-            elif outcome == "confirmed":
-                result.memories_confirmed += 1
-            else:
-                result.memories_skipped += 1
-
-        log.info(
-            "extraction.done",
-            role=role,
-            issue=issue_number,
-            stored=result.memories_stored,
-            confirmed=result.memories_confirmed,
-            skipped=result.memories_skipped,
-        )
-
-    except Exception as exc:
-        result.error = str(exc)
-        log.warning("extraction.failed", role=role, issue=issue_number, exc_info=True)
-
-    return result
+    All parameters are retained so re-enabling extraction is a single-file change.
+    """
+    # Reference params to satisfy static analysis; they're retained for future use
+    _ = (repo, task_title, files_changed, step_summaries, review_findings, spec_content, cwd)
+    log.info("extraction.skipped_noop", role=role, issue=issue_number)
+    return ExtractionResult()
 
 
 def _build_extraction_prompt(
diff --git a/sova/roles/reviewer.py b/sova/roles/reviewer.py
index 18a81a9..db13c09 100644
--- a/sova/roles/reviewer.py
+++ b/sova/roles/reviewer.py
@@ -646,32 +646,10 @@ async def _load_addressed_findings(self, ctx: ExecutionContext) -> list[dict]:
         return []
 
     async def _extract_review_memories(self, ctx: ExecutionContext, task: Task, review: ReviewResult) -> None:
-        """Extract learnings from this review into memory (non-fatal)."""
-        try:
-            from sova.knowledge.extraction import extract_memories
+        """No-op: automatic memory extraction is disabled.
 
-            await extract_memories(
-                role="reviewer",
-                issue_number=ctx.issue_number,
-                repo=ctx.repo,
-                task_title=task.title,
-                files_changed=[],
-                step_summaries=[f"review: {len(review.findings)} findings"],
-                review_findings=[
-                    {
-                        "file": f.file,
-                        "line": f.line,
-                        "severity": f.severity,
-                        "category": f.category,
-                        "description": f.description,
-                        "suggestion": f.suggestion,
-                    }
-                    for f in review.findings
-                ],
-                cwd=ctx.working_dir,
-            )
-        except Exception:
-            log.warning("reviewer.extract_memory_failed", exc_info=True)
+        Use ``/extract-knowledge`` for human-reviewed knowledge capture.
+        """
 
     async def _clear_current_step(self, ctx: ExecutionContext) -> None:
         """Clear the current_step sentinel on the TaskRun.
diff --git a/sova/roles/triage.py b/sova/roles/triage.py
index deac3c7..9f87409 100644
--- a/sova/roles/triage.py
+++ b/sova/roles/triage.py
@@ -167,58 +167,140 @@ async def assess_task_with_llm(self, task: Task, ctx: ExecutionContext) -> TaskA
         return self._heuristic_assess(task)
 
     def _heuristic_assess(self, task: Task) -> TaskAssessment:
-        """Quick heuristic-based assessment without LLM."""
+        """Quick heuristic-based assessment without LLM.
+
+        Uses structured signals (body length, section headings, code refs,
+        labels) to produce high-confidence results, reducing LLM fallback.
+        """
+        # Check labels first -- human-only takes priority regardless of body content
+        label_set = {lbl.lower() for lbl in (task.labels or [])}
+        if "agent:human-only" in label_set:
+            return TaskAssessment(
+                suitability="human_only",
+                confidence=0.95,
+                reasoning="Issue is labeled as human-only.",
+                estimated_complexity="moderate",
+                suggested_role="triage",
+            )
+
         has_body = bool(task.body and task.body.strip())
         if not has_body:
             return TaskAssessment(
                 suitability="needs_spec",
-                confidence=0.7,
+                confidence=0.9,
                 reasoning="Issue has no description; needs specification before work can begin.",
                 missing_context=["description", _ACCEPTANCE_CRITERIA],
                 estimated_complexity="moderate",
                 suggested_role="triage",
             )
 
-        body = task.body.strip().lower()
+        return self._assess_body_content(task.body.strip(), label_set)
 
-        # Check for acceptance criteria indicators
-        has_criteria = any(
-            marker in body
-            for marker in ["- [ ]", _ACCEPTANCE_CRITERIA, "expected behavior", "## scope", "## requirements"]
-        )
+    def _assess_body_content(self, body: str, label_set: set[str]) -> TaskAssessment:
+        """Classify issue by body content and label signals."""
+        body_lower = body.lower()
+        body_len = len(body)
 
-        # Check for file/code references
-        has_code_refs = any(
-            marker in body for marker in [".py", ".ts", ".js", ".sh", "`", "```", "function", "class ", "def "]
-        )
+        has_criteria = self._has_criteria_markers(body_lower)
+        has_code_refs = self._has_code_references(body_lower)
+        has_section_headings = body_lower.count("\n##") >= 1
+        has_type_label = any(lbl.startswith("type:") for lbl in label_set)
+        is_bug = "type:bug" in label_set or "bug" in label_set
+
+        complexity = self._estimate_complexity(body)
 
-        if not has_criteria and len(body) < 100:
+        if has_criteria and has_code_refs:
+            return TaskAssessment(
+                suitability="ready",
+                confidence=0.9,
+                reasoning="Issue has acceptance criteria and code references; ready for research.",
+                estimated_complexity=complexity,
+                suggested_role="researcher",
+            )
+
+        if is_bug and has_code_refs:
+            return TaskAssessment(
+                suitability="ready",
+                confidence=0.85,
+                reasoning="Bug report with code references; ready for research.",
+                estimated_complexity=complexity,
+                suggested_role="researcher",
+            )
+
+        if not has_criteria and body_len < 100:
             return TaskAssessment(
                 suitability="needs_spec",
-                confidence=0.6,
+                confidence=0.8,
                 reasoning="Issue has a short description without acceptance criteria.",
                 missing_context=[_ACCEPTANCE_CRITERIA, "expected behavior"],
-                estimated_complexity="moderate",
+                estimated_complexity="simple",
                 suggested_role="triage",
             )
 
-        if has_criteria and has_code_refs:
+        if has_criteria or (has_section_headings and body_len > 200):
             return TaskAssessment(
                 suitability="ready",
                 confidence=0.85,
-                reasoning="Issue has acceptance criteria and code references; ready for research.",
-                estimated_complexity="moderate",
+                reasoning="Issue has structured sections indicating clear scope; ready for research.",
+                estimated_complexity=complexity,
+                suggested_role="researcher",
+            )
+
+        if body_len > 300 and (has_code_refs or has_type_label):
+            return TaskAssessment(
+                suitability="ready",
+                confidence=0.8,
+                reasoning="Issue has a detailed description with contextual signals; ready for research.",
+                estimated_complexity=complexity,
                 suggested_role="researcher",
             )
 
         return TaskAssessment(
-            suitability="ready",
-            confidence=0.8,
-            reasoning="Issue has a title and description; ready for research.",
-            estimated_complexity="moderate",
+            suitability="needs_research",
+            confidence=0.75,
+            reasoning="Issue has a description but lacks structured criteria; needs research first.",
+            estimated_complexity=complexity,
             suggested_role="researcher",
         )
 
+    @staticmethod
+    def _has_criteria_markers(body_lower: str) -> bool:
+        """Check if body contains acceptance criteria markers."""
+        return any(
+            marker in body_lower
+            for marker in [
+                "- [ ]",
+                _ACCEPTANCE_CRITERIA,
+                "expected behavior",
+                "## scope",
+                "## requirements",
+                "## solution",
+                "## steps",
+                "## design",
+            ]
+        )
+
+    @staticmethod
+    def _has_code_references(body_lower: str) -> bool:
+        """Check if body contains code references."""
+        return any(
+            marker in body_lower
+            for marker in [".py", ".ts", ".js", ".sh", "`", "```", "function", "class ", "def ", "import "]
+        )
+
+    @staticmethod
+    def _estimate_complexity(body: str) -> str:
+        """Estimate task complexity from body signals."""
+        body_lower = body.lower()
+        body_len = len(body)
+        if body_len < 150:
+            return "simple"
+        if body_len > 1000 and body_lower.count("\n##") >= 1:
+            return "complex"
+        if any(w in body_lower for w in ["migration", "refactor", "breaking change", "epic"]):
+            return "complex"
+        return "moderate"
+
     def _parse_llm_assessment(self, text: str) -> TaskAssessment | None:
         """Parse Claude's JSON response into a TaskAssessment."""
         try:
diff --git a/tests/test_core.py b/tests/test_core.py
index 654126b..8b2159a 100644
--- a/tests/test_core.py
+++ b/tests/test_core.py
@@ -1170,19 +1170,12 @@ async def test_gate_check_passes_with_pr(self) -> None:
         assert gate.passed
 
     @patch("sova.core.steps.create_pr.git_ops.find_pr_for_issue", new_callable=AsyncMock, return_value=None)
-    @patch("sova.core.steps.create_pr.invoke")
     @patch("sova.core.steps.create_pr.run")
     @patch("sova.core.steps.create_pr.git_ops.create_pr")
-    async def test_execute_generates_rich_body(self, mock_create_pr, mock_run, mock_invoke, _find) -> None:
+    async def test_execute_generates_structured_body(self, mock_create_pr, mock_run, _find) -> None:
         from sova.core.steps.create_pr import CreatePRStep
-        from sova.llm.models import LLMResult
 
         mock_run.return_value = MagicMock(success=True, stdout="abc123 feat: add widget\n")
-        mock_invoke.return_value = LLMResult(
-            text="## Summary\n- Added widget support\n\nCloses #42",
-            model="sonnet",
-            cost_usd=Decimal("0.01"),
-        )
         mock_create_pr.return_value = MagicMock(number=10, url="https://github.com/x/y/pull/10")
 
         adapter = _mock_adapter()
@@ -1198,22 +1191,18 @@ async def test_execute_generates_rich_body(self, mock_create_pr, mock_run, mock_
         assert ctx.pr_number == 10
         body_arg = mock_create_pr.call_args.kwargs["body"]
         assert "## Summary" in body_arg
-        assert "Added widget" in body_arg
+        assert "Add widget" in body_arg
+        assert "Closes #42" in body_arg
+        assert "## Context" in body_arg
+        assert "We need a widget" in body_arg
 
     @patch("sova.core.steps.create_pr.git_ops.find_pr_for_issue", new_callable=AsyncMock, return_value=None)
-    @patch("sova.core.steps.create_pr.invoke")
     @patch("sova.core.steps.create_pr.run")
     @patch("sova.core.steps.create_pr.git_ops.create_pr")
-    async def test_execute_appends_closes_when_missing(self, mock_create_pr, mock_run, mock_invoke, _find) -> None:
+    async def test_execute_includes_closes_for_issue(self, mock_create_pr, mock_run, _find) -> None:
         from sova.core.steps.create_pr import CreatePRStep
-        from sova.llm.models import LLMResult
 
         mock_run.return_value = MagicMock(success=True, stdout="abc123 feat\n")
-        mock_invoke.return_value = LLMResult(
-            text="## Summary\n- Did stuff",
-            model="sonnet",
-            cost_usd=Decimal("0.01"),
-        )
         mock_create_pr.return_value = MagicMock(number=12, url="https://github.com/x/y/pull/12")
 
         ctx = _make_ctx(branch_name="feat/issue-42")
@@ -1224,17 +1213,15 @@ async def test_execute_appends_closes_when_missing(self, mock_create_pr, mock_ru
         assert "Closes #42" in body_arg
 
     @patch("sova.core.steps.create_pr.git_ops.find_pr_for_issue", new_callable=AsyncMock, return_value=None)
-    @patch("sova.core.steps.create_pr.invoke")
     @patch("sova.core.steps.create_pr.run")
     @patch("sova.core.steps.create_pr.git_ops.create_pr")
-    async def test_execute_falls_back_on_llm_failure(self, mock_create_pr, mock_run, mock_invoke, _find) -> None:
+    async def test_execute_body_includes_commits_and_diff(self, mock_create_pr, mock_run, _find) -> None:
         from sova.core.steps.create_pr import CreatePRStep
 
         mock_run.side_effect = [
             MagicMock(success=True, stdout="abc123 feat: add widget\n"),
             MagicMock(success=True, stdout=" src/app.py | 10 ++++\n 1 file changed, 10 insertions(+)\n"),
         ]
-        mock_invoke.side_effect = RuntimeError("LLM unavailable")
         mock_create_pr.return_value = MagicMock(number=11, url="https://github.com/x/y/pull/11")
 
         ctx = _make_ctx(
@@ -1253,19 +1240,12 @@ async def test_execute_falls_back_on_llm_failure(self, mock_create_pr, mock_run,
         assert "src/app.py" in body_arg
 
     @patch("sova.core.steps.create_pr.git_ops.find_pr_for_issue", new_callable=AsyncMock, return_value=None)
-    @patch("sova.core.steps.create_pr.invoke")
     @patch("sova.core.steps.create_pr.run")
     @patch("sova.core.steps.create_pr.git_ops.create_pr")
-    async def test_execute_assigns_pr_to_user(self, mock_create_pr, mock_run, mock_invoke, _find) -> None:
+    async def test_execute_assigns_pr_to_user(self, mock_create_pr, mock_run, _find) -> None:
         from sova.core.steps.create_pr import CreatePRStep
-        from sova.llm.models import LLMResult
 
         mock_run.return_value = MagicMock(success=True, stdout="abc123 feat\n")
-        mock_invoke.return_value = LLMResult(
-            text="## Summary\n- Added widget\n\nCloses #42",
-            model="sonnet",
-            cost_usd=Decimal("0.01"),
-        )
         mock_create_pr.return_value = MagicMock(number=10, url="https://github.com/x/y/pull/10")
 
         adapter = _mock_adapter()
@@ -1280,25 +1260,17 @@ async def test_execute_assigns_pr_to_user(self, mock_create_pr, mock_run, mock_i
         mock_assign.assert_awaited_once_with(10, assignee="xsovad06", repo="", github_user="xsovad06")
 
     @patch("sova.core.steps.create_pr.git_ops.find_pr_for_issue", new_callable=AsyncMock, return_value=None)
-    @patch("sova.core.steps.create_pr.invoke")
     @patch("sova.core.steps.create_pr.run")
     @patch("sova.core.steps.create_pr.git_ops.create_pr")
     async def test_execute_skips_assignment_when_no_github_user(
         self,
         mock_create_pr,
         mock_run,
-        mock_invoke,
         _find,
     ) -> None:
         from sova.core.steps.create_pr import CreatePRStep
-        from sova.llm.models import LLMResult
 
         mock_run.return_value = MagicMock(success=True, stdout="abc123 feat\n")
-        mock_invoke.return_value = LLMResult(
-            text="## Summary\n- Added widget\n\nCloses #42",
-            model="sonnet",
-            cost_usd=Decimal("0.01"),
-        )
         mock_create_pr.return_value = MagicMock(number=10, url="https://github.com/x/y/pull/10")
 
         ctx = _make_ctx(branch_name="feat/issue-42")
@@ -1341,6 +1313,52 @@ async def test_execute_transitions_to_in_review_on_adopt(self, mock_find) -> Non
 
         adapter.transition_state.assert_awaited_once_with("42", TaskState.IN_REVIEW)
 
+    @patch("sova.core.steps.create_pr.git_ops.find_pr_for_issue", new_callable=AsyncMock, return_value=None)
+    @patch("sova.core.steps.create_pr.run")
+    @patch("sova.core.steps.create_pr.git_ops.create_pr")
+    async def test_execute_whitespace_only_body_omits_context(self, mock_create_pr, mock_run, _find) -> None:
+        """Whitespace-only issue body should not produce a Context section."""
+        from sova.core.steps.create_pr import CreatePRStep
+
+        mock_run.return_value = MagicMock(success=True, stdout="abc123 feat: add widget\n")
+        mock_create_pr.return_value = MagicMock(number=10, url="https://github.com/x/y/pull/10")
+
+        adapter = _mock_adapter()
+        ctx = _make_ctx(
+            adapter=adapter,
+            task=Task(id="42", title="Add widget", body="   "),
+            branch_name="feat/issue-42",
+        )
+        step = CreatePRStep()
+        result = await step.execute(ctx)
+
+        assert result.success
+        body_arg = mock_create_pr.call_args.kwargs["body"]
+        assert "## Context" not in body_arg
+
+    @patch("sova.core.steps.create_pr.git_ops.find_pr_for_issue", new_callable=AsyncMock, return_value=None)
+    @patch("sova.core.steps.create_pr.run")
+    @patch("sova.core.steps.create_pr.git_ops.create_pr")
+    async def test_execute_none_body_omits_context(self, mock_create_pr, mock_run, _find) -> None:
+        """None issue body should not produce a Context section."""
+        from sova.core.steps.create_pr import CreatePRStep
+
+        mock_run.return_value = MagicMock(success=True, stdout="abc123 feat\n")
+        mock_create_pr.return_value = MagicMock(number=10, url="https://github.com/x/y/pull/10")
+
+        adapter = _mock_adapter()
+        ctx = _make_ctx(
+            adapter=adapter,
+            task=Task(id="42", title="Add widget", body=None),
+            branch_name="feat/issue-42",
+        )
+        step = CreatePRStep()
+        result = await step.execute(ctx)
+
+        assert result.success
+        body_arg = mock_create_pr.call_args.kwargs["body"]
+        assert "## Context" not in body_arg
+
 
 class TestHandoffToReviewerStep:
     async def test_writes_handoff_and_succeeds(self) -> None:
@@ -2781,29 +2799,66 @@ async def test_issueless_pr_title_has_no_issue_ref(self) -> None:
         with (
             patch("sova.core.steps.create_pr.run") as mock_run,
             patch("sova.core.steps.create_pr.git_ops.create_pr", new_callable=AsyncMock, return_value=pr_info),
-            patch("sova.core.steps.create_pr.invoke", new_callable=AsyncMock) as mock_invoke,
         ):
             mock_run.side_effect = [
                 MagicMock(success=True, stdout="abc123 feat: plan\n"),
                 MagicMock(success=True, stdout=" plan.py | 3 +++\n"),
             ]
-            mock_invoke.return_value = MagicMock(text="## Summary\nSprint plan", cost_usd=Decimal("0.01"))
             result = await step.execute(ctx)
 
         assert result.success
         assert ctx.pr_number == 99
         assert "(#" not in result.summary or "99" in result.summary
 
-    async def test_issueless_fallback_body_has_no_closes(self) -> None:
-        """Fallback PR body for issueless runs should omit Closes line."""
+    async def test_issueless_pr_body_has_no_closes(self) -> None:
+        """PR body for issueless runs should omit Closes line."""
         from sova.core.steps.create_pr import CreatePRStep
 
         ctx = _make_ctx(issue_number="", run_label="sprint-planning")
         ctx.task = None
-        body = CreatePRStep._build_fallback_body(ctx, "sprint plan", "abc123 feat: plan", "plan.py | 3 +++")
+        body = CreatePRStep._build_pr_body(ctx, "sprint plan", "abc123 feat: plan", "plan.py | 3 +++")
         assert "Closes" not in body
         assert "sprint plan" in body
 
+    async def test_pr_body_includes_issue_excerpt(self) -> None:
+        """PR body should include a truncated issue body excerpt."""
+        from sova.core.steps.create_pr import CreatePRStep
+
+        ctx = _make_ctx(branch_name="feat/issue-42", task=Task(id="42", title="Widget", body="Add widget support"))
+        body = CreatePRStep._build_pr_body(ctx, "Widget", "abc feat", "x.py | 3 +++")
+        assert "## Context" in body
+        assert "Add widget support" in body
+        assert "Closes #42" in body
+
+    async def test_pr_body_truncates_long_issue_body(self) -> None:
+        """Issue body excerpts longer than 500 chars should be truncated."""
+        from sova.core.steps.create_pr import CreatePRStep
+
+        long_body = "x" * 600
+        ctx = _make_ctx(branch_name="feat/issue-42", task=Task(id="42", title="Big", body=long_body))
+        body = CreatePRStep._build_pr_body(ctx, "Big", "abc feat", "x.py | 3 +++")
+        assert "## Context" in body
+        assert "..." in body
+        assert long_body not in body  # should be truncated
+
+    async def test_pr_body_omits_context_when_no_issue_body(self) -> None:
+        """PR body should not include Context section when issue has no body."""
+        from sova.core.steps.create_pr import CreatePRStep
+
+        ctx = _make_ctx(branch_name="feat/issue-42", task=Task(id="42", title="Fix", body=""))
+        body = CreatePRStep._build_pr_body(ctx, "Fix", "abc feat", "x.py | 3 +++")
+        assert "## Context" not in body
+        assert "Closes #42" in body
+
+    async def test_pr_body_omits_context_when_whitespace_only_body(self) -> None:
+        """PR body should not include Context section when issue body is whitespace-only."""
+        from sova.core.steps.create_pr import CreatePRStep
+
+        ctx = _make_ctx(branch_name="feat/issue-42", task=Task(id="42", title="Fix", body="   "))
+        body = CreatePRStep._build_pr_body(ctx, "Fix", "abc feat", "x.py | 3 +++")
+        assert "## Context" not in body
+        assert "Closes #42" in body
+
 
 # ---------------------------------------------------------------------------
 # RebaseStep
diff --git a/tests/test_extraction.py b/tests/test_extraction.py
index 65feaab..82f6ec6 100644
--- a/tests/test_extraction.py
+++ b/tests/test_extraction.py
@@ -1,4 +1,4 @@
-"""Tests for automatic memory extraction from agent runs."""
+"""Tests for memory extraction infrastructure."""
 
 from __future__ import annotations
 
@@ -6,7 +6,6 @@
 import os
 from decimal import Decimal
 from pathlib import Path
-from unittest.mock import AsyncMock, patch
 
 import pytest
 
@@ -294,118 +293,43 @@ async def test_dedup_promotes_at_threshold() -> None:
 # ---------------------------------------------------------------------------
 
 
-def _mock_llm_response(items: list[dict]) -> AsyncMock:
-    from sova.llm.models import LLMResult
-
-    mock = AsyncMock()
-    mock.return_value = LLMResult(
-        text=json.dumps(items),
-        model="haiku",
-        cost_usd=Decimal("0.005"),
-        input_tokens=100,
-        output_tokens=50,
-    )
-    return mock
-
-
-async def test_extract_memories_success() -> None:
-    from sova.knowledge.extraction import extract_memories
-    from sova.knowledge.memory import search
-
-    items = [
-        {
-            "category": "learning",
-            "title": "SQLAlchemy sessions need context managers",
-            "content": "Always use async with for session management",
-            "tags": ["sqlalchemy", "async"],
-        },
-    ]
-
-    with patch("sova.knowledge.extraction.invoke", _mock_llm_response(items)):
-        result = await extract_memories(
-            role="developer",
-            issue_number="42",
-            repo="user/repo",
-            task_title="Fix DB session leak",
-            files_changed=["sova/db/session.py"],
-            step_summaries=["develop: completed"],
-            cwd="/tmp",
-        )
-
-    assert result.memories_stored == 1
-    assert result.cost_usd == Decimal("0.005")
-    assert result.error is None
-
-    stored = await search(category="learning")
-    assert len(stored) == 1
-    assert stored[0].title == "SQLAlchemy sessions need context managers"
-    assert stored[0].repo == "user/repo"
-    assert stored[0].issue_number == "42"
-
-
-async def test_extract_memories_empty_response() -> None:
+async def test_extract_memories_is_noop() -> None:
+    """extract_memories is a no-op that returns an empty ExtractionResult."""
     from sova.knowledge.extraction import extract_memories
 
-    with patch("sova.knowledge.extraction.invoke", _mock_llm_response([])):
-        result = await extract_memories(
-            role="developer",
-            issue_number="1",
-            repo="user/repo",
-            task_title="Routine task",
-            files_changed=[],
-            step_summaries=[],
-            cwd="/tmp",
-        )
+    result = await extract_memories(
+        role="developer",
+        issue_number="42",
+        repo="user/repo",
+        task_title="Fix DB session leak",
+        files_changed=["sova/db/session.py"],
+        step_summaries=["develop: completed"],
+        cwd="/tmp",
+    )
 
     assert result.memories_stored == 0
+    assert result.memories_confirmed == 0
+    assert result.cost_usd == Decimal("0")
     assert result.error is None
 
 
-async def test_extract_memories_llm_failure() -> None:
+async def test_extract_memories_noop_with_all_optional_params() -> None:
+    """extract_memories accepts all optional params without error."""
     from sova.knowledge.extraction import extract_memories
 
-    mock = AsyncMock(side_effect=RuntimeError("Claude CLI failed"))
-    with patch("sova.knowledge.extraction.invoke", mock):
-        result = await extract_memories(
-            role="developer",
-            issue_number="1",
-            repo="user/repo",
-            task_title="Task",
-            files_changed=[],
-            step_summaries=[],
-            cwd="/tmp",
-        )
-
-    assert result.memories_stored == 0
-    assert result.error is not None
-    assert "Claude CLI failed" in result.error
-
-
-async def test_extract_memories_parse_failure() -> None:
-    from sova.knowledge.extraction import extract_memories
-    from sova.llm.models import LLMResult
-
-    mock = AsyncMock()
-    mock.return_value = LLMResult(
-        text="totally not json {{{",
-        model="haiku",
-        cost_usd=Decimal("0.003"),
-        input_tokens=50,
-        output_tokens=20,
+    result = await extract_memories(
+        role="reviewer",
+        issue_number="99",
+        repo="org/repo",
+        task_title="Review PR",
+        files_changed=["src/a.py", "src/b.py"],
+        step_summaries=["review: completed"],
+        review_findings=[{"file": "a.py", "line": 10, "severity": 5}],
+        spec_content="## Design\nSome spec content",
+        cwd="/tmp/workspace",
     )
-    with patch("sova.knowledge.extraction.invoke", mock):
-        result = await extract_memories(
-            role="developer",
-            issue_number="1",
-            repo="user/repo",
-            task_title="Task",
-            files_changed=[],
-            step_summaries=[],
-            cwd="/tmp",
-        )
 
     assert result.memories_stored == 0
-    assert result.cost_usd == Decimal("0.003")
     assert result.error is None
 
 
@@ -414,38 +338,15 @@ async def test_extract_memories_parse_failure() -> None:
 # ---------------------------------------------------------------------------
 
 
-async def test_step_execute_stores_memories() -> None:
+async def test_step_execute_returns_noop() -> None:
     from sova.core.steps.extract_memory import ExtractMemoryStep
-    from sova.knowledge.extraction import ExtractionResult
 
     step = ExtractMemoryStep()
-
-    mock_result = ExtractionResult(memories_stored=2, memories_confirmed=1, cost_usd=Decimal("0.01"))
-
-    with patch("sova.knowledge.extraction.extract_memories", new_callable=AsyncMock, return_value=mock_result):
-        ctx = _make_ctx()
-        result = await step.execute(ctx)
-
-    assert result.success is True
-    assert "2 new" in result.summary
-    assert "1 confirmed" in result.summary
-
-
-async def test_step_execute_on_failure() -> None:
-    from sova.core.steps.extract_memory import ExtractMemoryStep
-
-    step = ExtractMemoryStep()
-
-    with patch(
-        "sova.knowledge.extraction.extract_memories",
-        new_callable=AsyncMock,
-        side_effect=RuntimeError("boom"),
-    ):
-        ctx = _make_ctx()
-        result = await step.execute(ctx)
+    ctx = _make_ctx()
+    result = await step.execute(ctx)
 
     assert result.success is True
-    assert "non-fatal" in result.summary
+    assert "No novel learnings" in result.summary
 
 
 async def test_step_validate_always_passes() -> None:
diff --git a/tests/test_roles.py b/tests/test_roles.py
index 816dde6..8d51d18 100644
--- a/tests/test_roles.py
+++ b/tests/test_roles.py
@@ -1796,8 +1796,113 @@ async def test_triage_assess_without_body(self) -> None:
         assessment = await role.assess_task(task)
 
         assert assessment.suitability == "needs_spec"
+        assert assessment.confidence >= 0.9
         assert len(assessment.missing_context) > 0
 
+    async def test_triage_short_body_needs_spec(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        task = Task(id="1", title="Fix something", body="Short note.", state=TaskState.BACKLOG)
+        assessment = await role.assess_task(task)
+
+        assert assessment.suitability == "needs_spec"
+        assert assessment.confidence >= 0.8
+
+    async def test_triage_human_only_label(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        task = Task(
+            id="1",
+            title="Manual task",
+            body="Something detailed enough.",
+            state=TaskState.BACKLOG,
+            labels=["agent:human-only"],
+        )
+        assessment = await role.assess_task(task)
+
+        assert assessment.suitability == "human_only"
+        assert assessment.confidence >= 0.95
+
+    async def test_triage_human_only_label_with_empty_body(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        task = Task(
+            id="1",
+            title="Manual task",
+            body="",
+            state=TaskState.BACKLOG,
+            labels=["agent:human-only"],
+        )
+        assessment = await role.assess_task(task)
+
+        assert assessment.suitability == "human_only"
+        assert assessment.confidence >= 0.95
+
+    async def test_triage_bug_with_code_refs(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = "There is a bug in `sova/core/steps/create_pr.py` where the PR body is empty."
+        task = Task(id="1", title="Bug fix", body=body, state=TaskState.BACKLOG, labels=["type:bug"])
+        assessment = await role.assess_task(task)
+
+        assert assessment.suitability == "ready"
+        assert assessment.confidence >= 0.85
+
+    async def test_triage_structured_body_no_code_refs(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = (
+            "Implement a new feature.\n\n"
+            "## Scope\n"
+            "The feature should cover X, Y, and Z components.\n\n"
+            "## Requirements\n"
+            "Must handle edge cases A and B.\n"
+        )
+        task = Task(id="1", title="New feature", body=body, state=TaskState.BACKLOG)
+        assessment = await role.assess_task(task)
+
+        assert assessment.suitability == "ready"
+        assert assessment.confidence >= 0.85
+
+    async def test_triage_long_body_with_type_label(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = "A " * 200  # 400 chars, no criteria/code but has type label
+        task = Task(id="1", title="Task", body=body, state=TaskState.BACKLOG, labels=["type:feature"])
+        assessment = await role.assess_task(task)
+
+        assert assessment.suitability == "ready"
+        assert assessment.confidence >= 0.8
+
+    async def test_triage_medium_body_no_signals(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = "We should improve the user experience in various ways. " * 3  # ~170 chars
+        task = Task(id="1", title="Improve UX", body=body, state=TaskState.BACKLOG)
+        assessment = await role.assess_task(task)
+
+        assert assessment.suitability == "needs_research"
+        assert assessment.confidence >= 0.75
+
+    async def test_triage_complexity_estimation(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = (
+            "Major refactor needed.\n\n## Scope\n" + "Details. " * 100 + "\n\n## Requirements\n- Refactor all modules\n"
+        )
+        task = Task(id="1", title="Big refactor", body=body, state=TaskState.BACKLOG)
+        assessment = await role.assess_task(task)
+
+        assert assessment.estimated_complexity == "complex"
+
     async def test_researcher_assess_default(self) -> None:
         from sova.roles.researcher import ResearcherRole
 
@@ -2119,6 +2224,102 @@ def test_skip_multiple_labels_any_match(self) -> None:
         assert assessment.suitability == "human_only"
 
 
+# ---------------------------------------------------------------------------
+# TriageRole -- _heuristic_assess edge cases (label priority, helpers)
+# ---------------------------------------------------------------------------
+
+
+class TestTriageHeuristicEdgeCases:
+    """Tests for _heuristic_assess edge cases -- label priority and extracted helpers."""
+
+    def _make_task(self, title: str = "Test", body: str = "", labels: list[str] | None = None):
+        return Task(id="42", title=title, body=body, state=TaskState.BACKLOG, labels=labels or [])
+
+    def test_human_only_label_with_empty_body(self) -> None:
+        """agent:human-only label takes priority over empty-body needs_spec."""
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        task = self._make_task(body="", labels=["agent:human-only"])
+        result = role._heuristic_assess(task)
+        assert result.suitability == "human_only"
+        assert "human-only" in result.reasoning.lower()
+
+    def test_human_only_label_with_whitespace_body(self) -> None:
+        """agent:human-only label takes priority over whitespace-only body."""
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        task = self._make_task(body="   ", labels=["agent:human-only"])
+        result = role._heuristic_assess(task)
+        assert result.suitability == "human_only"
+
+    def test_human_only_label_with_full_body(self) -> None:
+        """agent:human-only label takes priority even with a detailed body."""
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        task = self._make_task(
+            body="Detailed description with `code refs` and acceptance criteria\n- [ ] Done",
+            labels=["agent:human-only"],
+        )
+        result = role._heuristic_assess(task)
+        assert result.suitability == "human_only"
+
+    def test_has_criteria_markers(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        assert TriageRole._has_criteria_markers("- [ ] task item")
+        assert TriageRole._has_criteria_markers("## scope\nsome text")
+        assert not TriageRole._has_criteria_markers("just a plain paragraph")
+
+    def test_has_code_references(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        assert TriageRole._has_code_references("update src/main.py")
+        assert TriageRole._has_code_references("use the `function` here")
+        assert not TriageRole._has_code_references("plain text without code")
+
+    def test_assess_body_content_bug_with_code_refs(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        result = role._assess_body_content("crash in module.py when calling func()", {"type:bug"})
+        assert result.suitability == "ready"
+        assert result.suggested_role == "researcher"
+
+    def test_assess_body_content_short_no_criteria(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        result = role._assess_body_content("Fix the bug", set())
+        assert result.suitability == "needs_spec"
+
+    def test_assess_body_content_structured_sections(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = "Description here.\n\n## Requirements\n" + "Detail " * 40
+        result = role._assess_body_content(body, set())
+        assert result.suitability == "ready"
+
+    def test_assess_body_content_long_with_type_label(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = "A " * 200
+        result = role._assess_body_content(body, {"type:feature"})
+        assert result.suitability == "ready"
+
+    def test_assess_body_content_fallback_needs_research(self) -> None:
+        from sova.roles.triage import TriageRole
+
+        role = TriageRole()
+        body = "A moderate description without clear markers or code. " * 3
+        result = role._assess_body_content(body, set())
+        assert result.suitability == "needs_research"
+
+
 # ---------------------------------------------------------------------------
 # TriageRole -- assess_task_with_llm
 # ---------------------------------------------------------------------------