diff --git a/internal/llm/contracts.go b/internal/llm/contracts.go
index c9dd44e..eb03d57 100644
--- a/internal/llm/contracts.go
+++ b/internal/llm/contracts.go
@@ -35,9 +35,10 @@ type Selection struct {
 
 // SelectedAgent is one selected reviewer agent.
 type SelectedAgent struct {
-	AgentID   string
-	Rationale string
-	Files     []string
+	AgentID      string
+	Rationale    string
+	Files        []string
+	AllowedFiles []string
 }
 
 // SelectionOptions contains context needed to validate selection output.
@@ -84,9 +85,10 @@ type selectionWire struct {
 }
 
 type selectedAgentWire struct {
-	AgentID   string   `json:"agent_id"`
-	Rationale string   `json:"rationale"`
-	Files     []string `json:"files"`
+	AgentID      string   `json:"agent_id"`
+	Rationale    string   `json:"rationale"`
+	Files        []string `json:"files"`
+	AllowedFiles []string `json:"allowed_files,omitempty"`
 }
 
 type threadActionWire struct {
@@ -155,10 +157,16 @@ func DecodeSelection(data []byte, opts SelectionOptions) (Selection, error) {
 				return Selection{}, fmt.Errorf("llm: selected file %q is not in changed files", file)
 			}
 		}
+		for _, file := range agent.AllowedFiles {
+			if strings.TrimSpace(file) == "" || !opts.ChangedFiles[file] {
+				return Selection{}, fmt.Errorf("llm: allowed file %q is not in changed files", file)
+			}
+		}
 		selection.SelectedAgents = append(selection.SelectedAgents, SelectedAgent{
-			AgentID:   agent.AgentID,
-			Rationale: sanitize(agent.Rationale),
-			Files:     append([]string(nil), agent.Files...),
+			AgentID:      agent.AgentID,
+			Rationale:    sanitize(agent.Rationale),
+			Files:        append([]string(nil), agent.Files...),
+			AllowedFiles: append([]string(nil), agent.AllowedFiles...),
 		})
 	}
 
diff --git a/internal/llm/contracts_test.go b/internal/llm/contracts_test.go
index 7823ae9..a3a0bca 100644
--- a/internal/llm/contracts_test.go
+++ b/internal/llm/contracts_test.go
@@ -16,7 +16,7 @@ func TestDecodeSelection(t *testing.T) {
 	}
 	got, err := DecodeSelection([]byte(`{
 		"schema_version": 1,
-		"selected_agents": [{"agent_id":"agent-1","rationale":"why <!-- codereview:skip -->","files":["main.go"]}],
+		"selected_agents": [{"agent_id":"agent-1","rationale":"why <!-- codereview:skip -->","files":["main.go"],"allowed_files":["main.go"]}],
 		"thread_actions": [{"thread_id":"thread-1","decision":"summarize_and_resolve","summary":"<!-- codereview:skip --> summary","safe_to_resolve_rationale":"safe"}],
 		"reasoning":"because <!-- codereview:skip -->"
 	}`), opts)
@@ -26,6 +26,9 @@ func TestDecodeSelection(t *testing.T) {
 	if got.SelectedAgents[0].AgentID != "agent-1" || got.ThreadActions[0].Decision != review.ThreadDecisionSummarizeAndResolve {
 		t.Fatalf("DecodeSelection = %#v", got)
 	}
+	if len(got.SelectedAgents[0].AllowedFiles) != 1 || got.SelectedAgents[0].AllowedFiles[0] != "main.go" {
+		t.Fatalf("DecodeSelection allowed_files = %#v, want main.go", got.SelectedAgents[0].AllowedFiles)
+	}
 	if strings.Contains(got.ThreadActions[0].Summary, "<!-- codereview:") ||
 		strings.Contains(got.SelectedAgents[0].Rationale, "<!-- codereview:") ||
 		strings.Contains(got.Reasoning, "<!-- codereview:") {
@@ -35,6 +38,7 @@ func TestDecodeSelection(t *testing.T) {
 	assertSelectionError(t, opts, `{"schema_version":2}`, "schema_version")
 	assertSelectionError(t, opts, `{"schema_version":1,"selected_agents":[{"agent_id":"missing"}]}`, "unknown selected agent")
 	assertSelectionError(t, opts, `{"schema_version":1,"selected_agents":[{"agent_id":"agent-1","files":["other.go"]}]}`, "changed files")
+	assertSelectionError(t, opts, `{"schema_version":1,"selected_agents":[{"agent_id":"agent-1","files":["main.go"],"allowed_files":["other.go"]}]}`, "allowed file")
 	assertSelectionError(t, opts, `{"schema_version":1,"thread_actions":[{"thread_id":"missing","decision":"skip"}]}`, "unknown thread")
 	assertSelectionError(t, opts, `{"schema_version":1,"thread_actions":[{"thread_id":"thread-1","decision":"summarize_only"}]}`, "summary")
 	assertSelectionError(t, opts, `{"schema_version":1,"thread_actions":[{"thread_id":"thread-1","decision":"summarize_and_resolve","summary":"summary"}]}`, "safe_to_resolve_rationale")
diff --git a/internal/pipeline/pipeline.go b/internal/pipeline/pipeline.go
index a596b1d..7522a48 100644
--- a/internal/pipeline/pipeline.go
+++ b/internal/pipeline/pipeline.go
@@ -15,6 +15,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -1089,7 +1090,13 @@ func runSelectionPhase(ctx context.Context, opts Options, req selectionPhaseRequ
 	}
 	model, effort := runtimeConfig.model, runtimeConfig.effort
 
-	selectionPrompt, err := buildSelectionPrompt(req.ReviewPR, req.Catalog, req.ParsedDiff.Patches, req.Threads, req.MaxAgents, req.SelectionPromptInstructions)
+	promptInput, promptDeps, err := selectionPromptInputFromArtifacts(req.Artifacts, req.Threads)
+	if err != nil {
+		return llm.Selection{}, sessionDraft{}, ledger.Session{}, err
+	}
+	dependencyTaskIDs := []string{dossierSummaryTaskID}
+	fingerprintDeps := append(append([]string(nil), dependencyTaskIDs...), promptDeps...)
+	selectionPrompt, err := buildSelectionPrompt(req.Catalog, promptInput, req.MaxAgents, req.SelectionPromptInstructions)
 	if err != nil {
 		return llm.Selection{}, sessionDraft{}, ledger.Session{}, err
 	}
@@ -1109,17 +1116,18 @@ func runSelectionPhase(ctx context.Context, opts Options, req selectionPhaseRequ
 	}
 	if strings.TrimSpace(req.RunID) != "" {
 		selection, selectionSession, ledgerSession, err := runStructuredTask(ctx, opts, llmTaskSpec{
-			runID:            req.RunID,
-			taskID:           orchestratorSelectionStage,
-			phase:            "selection",
-			inputFingerprint: llmTaskFingerprint(opts.Adapter.Name(), orchestratorSelectionStage, "selection", model, effort, selectionPrompt, nil),
-			artifacts:        req.Artifacts,
-			role:             ledger.SessionRoleOrchestrator,
-			model:            model,
-			effort:           effort,
-			logPath:          selectionLog,
-			prompt:           selectionPrompt,
-			resumeSessionID:  req.ResumeSessionID,
+			runID:             req.RunID,
+			taskID:            orchestratorSelectionStage,
+			phase:             "selection",
+			dependencyTaskIDs: dependencyTaskIDs,
+			inputFingerprint:  llmTaskFingerprint(opts.Adapter.Name(), orchestratorSelectionStage, "selection", model, effort, selectionPrompt, fingerprintDeps),
+			artifacts:         req.Artifacts,
+			role:              ledger.SessionRoleOrchestrator,
+			model:             model,
+			effort:            effort,
+			logPath:           selectionLog,
+			prompt:            selectionPrompt,
+			resumeSessionID:   req.ResumeSessionID,
 		}, decode)
 		if err != nil {
 			return llm.Selection{}, selectionSession, ledgerSession, err
@@ -1575,6 +1583,9 @@ func validateLLMTaskMetadata(meta llmTaskMetadata, spec llmTaskSpec, adapter str
 	if meta.Phase != spec.phase {
 		return fmt.Errorf("pipeline: LLM task %q phase = %q, want %q", spec.taskID, meta.Phase, spec.phase)
 	}
+	if !slices.Equal(meta.DependencyTaskIDs, spec.dependencyTaskIDs) {
+		return fmt.Errorf("pipeline: LLM task %q dependency task ids = %#v, want %#v; pass --rerun to start a fresh review", spec.taskID, meta.DependencyTaskIDs, spec.dependencyTaskIDs)
+	}
 	if strings.TrimSpace(adapter) != "" && meta.Adapter != adapter {
 		return fmt.Errorf("pipeline: LLM task %q adapter = %q, want %q; pass --rerun to start a fresh review", spec.taskID, meta.Adapter, adapter)
 	}
@@ -2311,6 +2322,38 @@ type selectionAgentPrompt struct {
 	NeedsFullFileContent bool     `json:"needs_full_file_content"`
 }
 
+type selectionPromptDossier struct {
+	PRIntent     string `json:"pr_intent"`
+	ChangeMap    string `json:"change_map"`
+	RepoGuidance string `json:"repo_guidance"`
+	Discussion   string `json:"discussion"`
+}
+
+type selectionPromptWorkbench struct {
+	CheckoutMode string                  `json:"checkout_mode"`
+	PR           workbenchPRIdentity     `json:"pr"`
+	Base         workbenchBranchArtifact `json:"base"`
+	Head         workbenchBranchArtifact `json:"head"`
+}
+
+type selectionThreadPrompt struct {
+	ThreadID   string `json:"thread_id"`
+	Path       string `json:"path"`
+	Line       int    `json:"line,omitempty"`
+	Side       string `json:"side,omitempty"`
+	AnchorKind string `json:"anchor_kind,omitempty"`
+	Resolved   bool   `json:"resolved,omitempty"`
+	Status     string `json:"status,omitempty"`
+	Summary    string `json:"summary,omitempty"`
+}
+
+type selectionPromptInput struct {
+	ChangedFiles []string                 `json:"changed_files"`
+	Dossier      selectionPromptDossier   `json:"dossier"`
+	Workbench    selectionPromptWorkbench `json:"workbench"`
+	Threads      []selectionThreadPrompt  `json:"threads,omitempty"`
+}
+
 type promptPR struct {
 	Ref    gitprovider.PRRef       `json:"ref"`
 	Title  string                  `json:"title"`
@@ -2367,18 +2410,23 @@ func fetchFileOptional(ctx context.Context, provider ReadProvider, ref gitprovid
 	return data, err
 }
 
-const defaultSelectionTask = "select reviewer agents and thread actions; return selection JSON only"
+const defaultSelectionTask = "select reviewer agents and thread actions from dossier/workbench context; return selection JSON only"
 
-func buildSelectionPrompt(pr gitprovider.PR, catalog agents.Catalog, patches []FilePatch, threads []gitprovider.InlineThread, maxAgents int, selectionInstructions string) (string, error) {
+func buildSelectionPrompt(catalog agents.Catalog, input selectionPromptInput, maxAgents int, selectionInstructions string) (string, error) {
+	threadIDs := make([]string, 0, len(input.Threads))
+	for _, thread := range input.Threads {
+		threadIDs = append(threadIDs, thread.ThreadID)
+	}
 	payload := map[string]any{
 		"task":                defaultSelectionTask,
-		"output_contract":     selectionOutputContract(catalog.Agents, patches, threads, maxAgents),
+		"output_contract":     selectionOutputContract(catalog.Agents, input.ChangedFiles, threadIDs, maxAgents),
 		"schema":              "selection",
 		"max_selected_agents": maxAgents,
-		"pr":                  promptPRFromPR(pr),
 		"agents":              selectionAgentPromptsFromCatalog(catalog),
-		"changed_files":       patchPaths(patches),
-		"threads":             threads,
+		"changed_files":       append([]string(nil), input.ChangedFiles...),
+		"dossier":             input.Dossier,
+		"workbench":           input.Workbench,
+		"threads":             input.Threads,
 	}
 	if instructions := strings.TrimSpace(selectionInstructions); instructions != "" {
 		payload["selection_instructions"] = instructions
@@ -2390,6 +2438,120 @@ func buildSelectionPrompt(pr gitprovider.PR, catalog agents.Catalog, patches []F
 	return string(body), nil
 }
 
+func selectionPromptInputFromArtifacts(paths ArtifactPaths, threads []gitprovider.InlineThread) (selectionPromptInput, []string, error) {
+	prIntentPath, err := paths.DossierFinalPath("pr-intent.md")
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	changeMapPath, err := paths.DossierFinalPath("change-map.md")
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	repoGuidancePath, err := paths.DossierFinalPath("repo-guidance.md")
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	discussionPath, err := paths.DossierFinalPath("discussion.md")
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	prIntent, err := selectionPromptContentFromPath(prIntentPath)
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	changeMap, err := selectionPromptContentFromPath(changeMapPath)
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	repoGuidance, err := selectionPromptContentFromPath(repoGuidancePath)
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	discussion, err := selectionPromptContentFromPath(discussionPath)
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+
+	indexBytes, err := os.ReadFile(paths.DossierIndexPath()) // #nosec G304 -- artifact path is pipeline-owned under the selected run/workbench root.
+	if err != nil {
+		return selectionPromptInput{}, nil, fmt.Errorf("pipeline: read dossier artifact %s: %w", filepath.Base(paths.DossierIndexPath()), err)
+	}
+	metaPath := paths.WorkbenchMetadataPath()
+	metaBytes, err := os.ReadFile(metaPath) // #nosec G304 -- artifact path is pipeline-owned under the selected run/workbench root.
+	if err != nil {
+		return selectionPromptInput{}, nil, fmt.Errorf("pipeline: read workbench metadata: %w", err)
+	}
+	var meta workbenchMetadataArtifact
+	if err := json.Unmarshal(metaBytes, &meta); err != nil {
+		return selectionPromptInput{}, nil, fmt.Errorf("pipeline: decode workbench metadata: %w", err)
+	}
+	summaryPath, err := paths.DossierSummaryPath("discussion.json")
+	if err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+	var summary dossierDiscussionSummaryArtifact
+	if err := readJSONFile(summaryPath, &summary); err != nil {
+		return selectionPromptInput{}, nil, err
+	}
+
+	input := selectionPromptInput{
+		ChangedFiles: append([]string(nil), meta.FingerprintInputs.ChangedFiles...),
+		Dossier: selectionPromptDossier{
+			PRIntent:     prIntent,
+			ChangeMap:    changeMap,
+			RepoGuidance: repoGuidance,
+			Discussion:   discussion,
+		},
+		Workbench: selectionPromptWorkbench{
+			CheckoutMode: meta.CheckoutMode,
+			PR:           meta.PR,
+			Base:         meta.Base,
+			Head:         meta.Head,
+		},
+		Threads: selectionThreadPrompts(threads, summary),
+	}
+	deps := []string{
+		"dossier_index=" + sha256Hex(indexBytes),
+		"workbench_metadata=" + sha256Hex(metaBytes),
+	}
+	return input, deps, nil
+}
+
+func selectionPromptContentFromPath(path string) (string, error) {
+	data, err := os.ReadFile(path) // #nosec G304 -- artifact path is pipeline-owned under the selected run/workbench root.
+	if err != nil {
+		return "", fmt.Errorf("pipeline: read dossier artifact %s: %w", filepath.Base(path), err)
+	}
+	return string(data), nil
+}
+
+func selectionThreadPrompts(threads []gitprovider.InlineThread, summary dossierDiscussionSummaryArtifact) []selectionThreadPrompt {
+	summaryByAnchor := make(map[string]dossierInlineThreadSummaryArtifact, len(summary.InlineThreads))
+	for _, thread := range summary.InlineThreads {
+		key := dossierInlineThreadAnchorKey(thread.Path, thread.Side, thread.Line, thread.AnchorKind)
+		summaryByAnchor[key] = thread
+	}
+	out := make([]selectionThreadPrompt, 0, len(threads))
+	for _, thread := range threads {
+		promptThread := selectionThreadPrompt{
+			ThreadID:   string(thread.ID),
+			Path:       thread.Path,
+			Line:       thread.Line,
+			Side:       string(thread.Side),
+			AnchorKind: string(thread.SubjectType),
+			Resolved:   thread.Resolved,
+		}
+		if summarized, ok := summaryByAnchor[dossierInlineThreadAnchorKey(thread.Path, string(thread.Side), thread.Line, string(thread.SubjectType))]; ok {
+			promptThread.Status = summarized.Status
+			promptThread.Summary = summarized.Summary
+		} else if len(thread.Comments) > 0 {
+			promptThread.Summary = singleLineExcerpt(thread.Comments[0].Body, dossierFinalExcerptRunes)
+		}
+		out = append(out, promptThread)
+	}
+	return out
+}
+
 func buildRollupPrompt(pr gitprovider.PR, findings []review.Finding, reviewerFailures []ReviewerFailure) (string, error) {
 	payload := map[string]any{
 		"task":              "dedupe findings and return rollup JSON only",
@@ -2466,16 +2628,11 @@ type outputContract struct {
 	Example        any      `json:"example"`
 }
 
-func selectionOutputContract(agents []agents.Agent, patches []FilePatch, threads []gitprovider.InlineThread, maxAgents int) outputContract {
+func selectionOutputContract(agents []agents.Agent, changedFiles []string, threadIDs []string, maxAgents int) outputContract {
 	agentIDs := make([]string, 0, len(agents))
 	for _, agent := range agents {
 		agentIDs = append(agentIDs, agent.ID)
 	}
-	changedFiles := patchPaths(patches)
-	threadIDs := make([]string, 0, len(threads))
-	for _, thread := range threads {
-		threadIDs = append(threadIDs, string(thread.ID))
-	}
 	example := map[string]any{
 		"schema_version":  1,
 		"selected_agents": selectionExampleAgents(agentIDs, changedFiles),
@@ -2493,12 +2650,13 @@ func selectionOutputContract(agents []agents.Agent, patches []FilePatch, threads
 			"schema_version must be 1.",
 			"selected_agents[].agent_id must be one of the allowed_agent_ids.",
 			"selected_agents[].files must contain only paths from changed_files.",
+			"selected_agents[].allowed_files must contain only paths from changed_files when present.",
 			"selected_agents must contain at most max_selected_agents entries, ordered from highest to lowest review value.",
 			"thread_actions must be an empty array when there are no threads.",
 		},
 		ResponseSchema: map[string]any{
 			"schema_version":  "number, required, must be 1",
-			"selected_agents": "array of {agent_id: string, rationale: string, files: string[]}",
+			"selected_agents": "array of {agent_id: string, rationale: string, files: string[], allowed_files?: string[]}",
 			"thread_actions":  "array of {thread_id: string, decision: string, summary: string, safe_to_resolve_rationale: string}",
 			"reasoning":       "string",
 		},
diff --git a/internal/pipeline/pipeline_test.go b/internal/pipeline/pipeline_test.go
index 009f1f2..58f4f3d 100644
--- a/internal/pipeline/pipeline_test.go
+++ b/internal/pipeline/pipeline_test.go
@@ -397,7 +397,7 @@ func TestDryRunSelectionPromptInstructionsStayInsideStructuredPayload(t *testing
 	if !strings.Contains(selectionPrompt, `"selection_instructions": "Prefer applies_when over prompt wording when routing."`) {
 		t.Fatalf("selection prompt missing custom instruction field: %s", selectionPrompt)
 	}
-	if !strings.Contains(selectionPrompt, `"task": "select reviewer agents and thread actions; return selection JSON only"`) {
+	if !strings.Contains(selectionPrompt, `"task": "`+defaultSelectionTask+`"`) {
 		t.Fatalf("selection prompt missing stable task field: %s", selectionPrompt)
 	}
 	if !strings.Contains(selectionPrompt, `"output_contract"`) || !strings.Contains(selectionPrompt, `"schema": "selection"`) {
@@ -518,17 +518,18 @@ func TestSelectionOnlyPromptPreservesRoutingContractWithoutReviewerPromptBodies(
 	trustCurrentTempFixtures(t)
 	req.Profile.AgentSources = []string{dir}
 	req.SelectionPromptInstructions = "Prefer applies_when over prompt wording when routing."
-	provider.diff.Raw = smallDiff("main.go") + smallDiff("other.go")
+	provider.diff.Raw = largeDiff("main.go", "+selection_prompt_should_not_embed_this_unique_hunk_line\n") + smallDiff("other.go")
 	provider.pr.Body = "Selection prompt body should stay out of prompt payloads."
 	adapter := &llm.FakeAdapter{NameValue: "fake-llm"}
 	adapter.Queue(fakeLLMResult("dossier-summary-session", discussionSummaryJSON(nil, []threadSummary{{path: "main.go", line: 2, status: "unresolved", summary: "Open thread at main.go:2"}}), 8, 2))
 	adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:alpha", "main.go"), 10, 2))
 
-	if _, err := selectionOnlyForTest(ctx, Options{
+	result, err := selectionOnlyForTest(ctx, Options{
 		Provider: provider,
 		Adapter:  adapter,
 		Now:      fixedNow,
-	}, selectionRequestFromReview(req, t.TempDir())); err != nil {
+	}, selectionRequestFromReview(req, t.TempDir()))
+	if err != nil {
 		t.Fatalf("SelectionOnly: %v", err)
 	}
 
@@ -538,14 +539,15 @@ func TestSelectionOnlyPromptPreservesRoutingContractWithoutReviewerPromptBodies(
 	}
 	selectionPrompt := requests[1].Prompt
 	var payload struct {
-		Task                  string                     `json:"task"`
-		Schema                string                     `json:"schema"`
-		SelectionInstructions string                     `json:"selection_instructions"`
-		OutputContract        map[string]any             `json:"output_contract"`
-		PR                    promptPR                   `json:"pr"`
-		Agents                []selectionAgentPrompt     `json:"agents"`
-		ChangedFiles          []string                   `json:"changed_files"`
-		Threads               []gitprovider.InlineThread `json:"threads"`
+		Task                  string                   `json:"task"`
+		Schema                string                   `json:"schema"`
+		SelectionInstructions string                   `json:"selection_instructions"`
+		OutputContract        map[string]any           `json:"output_contract"`
+		Agents                []selectionAgentPrompt   `json:"agents"`
+		ChangedFiles          []string                 `json:"changed_files"`
+		Dossier               selectionPromptDossier   `json:"dossier"`
+		Workbench             selectionPromptWorkbench `json:"workbench"`
+		Threads               []selectionThreadPrompt  `json:"threads"`
 	}
 	if err := json.Unmarshal([]byte(selectionPrompt), &payload); err != nil {
 		t.Fatalf("unmarshal selection prompt: %v", err)
@@ -556,16 +558,24 @@ func TestSelectionOnlyPromptPreservesRoutingContractWithoutReviewerPromptBodies(
 	if payload.Task != defaultSelectionTask || payload.Schema != "selection" || payload.OutputContract == nil {
 		t.Fatalf("selection prompt envelope = %#v, want task/schema/output contract", payload)
 	}
-	if payload.PR.Title != provider.pr.Title || payload.PR.URL != provider.pr.URL || payload.PR.Author.Login != provider.pr.Author.Login ||
-		payload.PR.Base.SHA != provider.pr.Base.SHA || payload.PR.Head.SHA != provider.pr.Head.SHA {
-		t.Fatalf("selection prompt pr = %#v, want title/url/author/base/head from provider PR", payload.PR)
-	}
 	if !reflect.DeepEqual(payload.ChangedFiles, []string{"main.go", "other.go"}) {
 		t.Fatalf("changed files = %#v, want main.go/other.go", payload.ChangedFiles)
 	}
-	if len(payload.Threads) != 1 || payload.Threads[0].ID != "thread-1" || payload.Threads[0].Path != "main.go" {
+	if len(payload.Threads) != 1 || payload.Threads[0].ThreadID != "thread-1" || payload.Threads[0].Path != "main.go" || payload.Threads[0].Summary != "Open thread at main.go:2" {
 		t.Fatalf("threads = %#v, want thread-1 on main.go", payload.Threads)
 	}
+	if !strings.Contains(payload.Dossier.PRIntent, provider.pr.Title) || !strings.Contains(payload.Dossier.PRIntent, provider.pr.Body) {
+		t.Fatalf("pr intent = %q, want title and PR body", payload.Dossier.PRIntent)
+	}
+	if !strings.Contains(payload.Dossier.ChangeMap, "main.go") || !strings.Contains(payload.Dossier.Discussion, "Open thread at main.go:2") {
+		t.Fatalf("dossier payload = %#v, want change map and summarized discussion", payload.Dossier)
+	}
+	if payload.Workbench.Head.SHA != provider.pr.Head.SHA || payload.Workbench.Base.SHA != provider.pr.Base.SHA {
+		t.Fatalf("workbench payload = %#v, want review head/base SHAs", payload.Workbench)
+	}
+	if payload.Workbench.CheckoutMode == "" || payload.Workbench.PR.Number != provider.pr.Ref.Number {
+		t.Fatalf("workbench payload = %#v, want checkout mode and PR identity", payload.Workbench)
+	}
 	if len(payload.Agents) != 2 {
 		t.Fatalf("agents len = %d, want 2", len(payload.Agents))
 	}
@@ -591,8 +601,18 @@ func TestSelectionOnlyPromptPreservesRoutingContractWithoutReviewerPromptBodies(
 			t.Fatalf("selection prompt leaked reviewer execution detail %q: %s", forbidden, selectionPrompt)
 		}
 	}
-	if strings.Contains(selectionPrompt, "Selection prompt body should stay out of prompt payloads.") {
-		t.Fatalf("selection prompt leaked PR body: %s", selectionPrompt)
+	for _, forbidden := range []string{"diff --git", "@@ -", "@@ +"} {
+		if strings.Contains(selectionPrompt, forbidden) {
+			t.Fatalf("selection prompt leaked diff hunk content %q: %s", forbidden, selectionPrompt)
+		}
+	}
+	if strings.Contains(selectionPrompt, "selection_prompt_should_not_embed_this_unique_hunk_line") {
+		t.Fatalf("selection prompt leaked raw patch content: %s", selectionPrompt)
+	}
+	for _, forbidden := range []string{result.Artifacts.WorkbenchRepoDir, result.Artifacts.WorkbenchScratch, result.Artifacts.DossierDir, `"source_repo_root"`, `"repo_path"`, `"scratch_path"`, `"metadata_path"`, `"metadata_sha256"`, `"fingerprint_inputs"`, `"root_dir"`, `"index_path"`, `"index_sha256"`} {
+		if strings.Contains(selectionPrompt, forbidden) {
+			t.Fatalf("selection prompt leaked harness-only workbench detail %q: %s", forbidden, selectionPrompt)
+		}
 	}
 }
 
@@ -2333,6 +2353,49 @@ func TestRunStructuredTaskRejectsAdapterMismatchBeforeRetry(t *testing.T) {
 	}
 }
 
+func TestRunStructuredTaskRejectsDependencyTaskIDMismatchBeforeRetry(t *testing.T) {
+	ctx := context.Background()
+	artifacts := ArtifactPathsFromDir(t.TempDir())
+	spec := llmTaskSpec{
+		runID:             "run-dependency-mismatch",
+		taskID:            orchestratorSelectionStage,
+		phase:             "selection",
+		dependencyTaskIDs: []string{dossierSummaryTaskID},
+		inputFingerprint:  "fingerprint",
+		artifacts:         artifacts,
+		role:              ledger.SessionRoleOrchestrator,
+		model:             "model",
+		effort:            "medium",
+		prompt:            "prompt",
+	}
+	meta := llmTaskMetadata{
+		SchemaVersion:     llmTaskSchemaVersion,
+		TaskID:            spec.taskID,
+		Phase:             spec.phase,
+		DependencyTaskIDs: nil,
+		InputFingerprint:  spec.inputFingerprint,
+		Adapter:           "fake-llm",
+		Status:            llmTaskStatusFailedBlocking,
+		SessionRowID:      "session-row",
+		ProviderSessionID: "provider-session",
+	}
+	if err := writeLLMTaskMetadata(artifacts, meta); err != nil {
+		t.Fatalf("writeLLMTaskMetadata: %v", err)
+	}
+	adapter := &llm.FakeAdapter{NameValue: "fake-llm", SupportsResumeValue: true}
+	adapter.Queue(fakeLLMResult("new-session", `"ok"`, 1, 1))
+
+	_, _, _, err := runStructuredTask[string](ctx, Options{Adapter: adapter}, spec, func(data []byte) (string, error) {
+		return string(data), nil
+	})
+	if err == nil || !strings.Contains(err.Error(), "dependency task ids") {
+		t.Fatalf("runStructuredTask error = %v, want dependency task id mismatch", err)
+	}
+	if len(adapter.Requests()) != 0 || len(adapter.Resumes()) != 0 {
+		t.Fatalf("adapter invoked despite dependency mismatch: starts=%#v resumes=%#v", adapter.Requests(), adapter.Resumes())
+	}
+}
+
 func TestRunStructuredTaskReviewerStartFailureIsBlocking(t *testing.T) {
 	ctx := context.Background()
 	artifacts := ArtifactPathsFromDir(t.TempDir())
@@ -3536,7 +3599,7 @@ func TestDryRunMultiAgentSessionsMapFindingsToReviewerSessions(t *testing.T) {
 			if !strings.Contains(request.Prompt, `"applies_when"`) {
 				t.Fatalf("selection prompt missing applies_when routing metadata: %s", request.Prompt)
 			}
-			for _, forbidden := range []string{"Review alpha files.", "Review beta files.", `"prompt"`, `"owner"`, `"provenance"`, `"overridden"`} {
+			for _, forbidden := range []string{"Review alpha files.", "Review beta files.", `"prompt"`, `"provenance"`, `"overridden"`} {
 				if strings.Contains(request.Prompt, forbidden) {
 					t.Fatalf("selection prompt leaked reviewer execution instructions %q: %s", forbidden, request.Prompt)
 				}
@@ -3883,7 +3946,7 @@ func TestDryRunRejectsSelfReviewWhenReviewerCredentialsMatchAuthor(t *testing.T)
 }
 
 func TestSelectionOutputContractExampleHasNoAgentsWhenCatalogEmpty(t *testing.T) {
-	contract := selectionOutputContract(nil, []FilePatch{{Path: "main.go"}}, nil, 3)
+	contract := selectionOutputContract(nil, []string{"main.go"}, nil, 3)
 	example, ok := contract.Example.(map[string]any)
 	if !ok {
 		t.Fatalf("Example = %#v, want map", contract.Example)
@@ -3899,10 +3962,8 @@ func TestSelectionOutputContractExampleHasNoAgentsWhenCatalogEmpty(t *testing.T)
 
 func TestSelectionPromptIncludesMaxSelectedAgentsContract(t *testing.T) {
 	prompt, err := buildSelectionPrompt(
-		gitprovider.PR{},
 		agents.Catalog{Agents: []agents.Agent{{ID: "agent-1"}}},
-		[]FilePatch{{Path: "main.go"}},
-		nil,
+		selectionPromptInput{ChangedFiles: []string{"main.go"}},
 		3,
 		"",
 	)
@@ -3928,6 +3989,202 @@ func TestSelectionPromptIncludesMaxSelectedAgentsContract(t *testing.T) {
 	if !strings.Contains(strings.Join(payload.OutputContract.Instructions, "\n"), "at most max_selected_agents") {
 		t.Fatalf("instructions = %#v, want max-selected-agents guidance", payload.OutputContract.Instructions)
 	}
+	if !strings.Contains(prompt, "allowed_files") {
+		t.Fatalf("selection prompt contract missing allowed_files: %s", prompt)
+	}
+}
+
+func TestSelectionOutputContractExampleOmitsAllowedFilesForBroadReviewer(t *testing.T) {
+	contract := selectionOutputContract([]agents.Agent{{ID: "agent-1"}}, []string{"main.go"}, nil, 3)
+	example, ok := contract.Example.(map[string]any)
+	if !ok {
+		t.Fatalf("Example = %#v, want map", contract.Example)
+	}
+	selected, ok := example["selected_agents"].([]map[string]any)
+	if !ok || len(selected) != 1 {
+		t.Fatalf("selected_agents = %#v, want one example reviewer", example["selected_agents"])
+	}
+	if _, ok := selected[0]["allowed_files"]; ok {
+		t.Fatalf("selection example unexpectedly set allowed_files for broad reviewer: %#v", selected[0])
+	}
+}
+
+func TestSelectionPromptDependenciesTrackDossierAndWorkbenchDigests(t *testing.T) {
+	ctx := context.Background()
+	provider, req := dryRunHarness(t)
+	adapter := &llm.FakeAdapter{NameValue: "fake-llm"}
+	adapter.Queue(fakeLLMResult("dossier-summary-session", discussionSummaryJSON(nil, nil), 8, 2))
+	adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:reviewer", "main.go"), 10, 2))
+
+	result, err := selectionOnlyForTest(ctx, Options{
+		Provider: provider,
+		Adapter:  adapter,
+		Now:      fixedNow,
+	}, selectionRequestFromReview(req, t.TempDir()))
+	if err != nil {
+		t.Fatalf("SelectionOnly: %v", err)
+	}
+
+	_, deps1, err := selectionPromptInputFromArtifacts(result.Artifacts, result.Threads)
+	if err != nil {
+		t.Fatalf("selectionPromptInputFromArtifacts first: %v", err)
+	}
+	if len(deps1) != 2 {
+		t.Fatalf("deps len = %d, want dossier/workbench deps", len(deps1))
+	}
+
+	indexPath := result.Artifacts.DossierIndexPath()
+	if err := os.WriteFile(indexPath, []byte(`{"hash_algorithm":"sha256","files":[{"path":"final/pr-intent.md","sha256":"changed"}]}`+"\n"), 0o600); err != nil {
+		t.Fatalf("WriteFile(%s): %v", indexPath, err)
+	}
+	_, deps2, err := selectionPromptInputFromArtifacts(result.Artifacts, result.Threads)
+	if err != nil {
+		t.Fatalf("selectionPromptInputFromArtifacts dossier change: %v", err)
+	}
+	if reflect.DeepEqual(deps1, deps2) {
+		t.Fatalf("deps after dossier index change = %#v, want changed from %#v", deps2, deps1)
+	}
+
+	metaPath := result.Artifacts.WorkbenchMetadataPath()
+	var meta workbenchMetadataArtifact
+	if err := readJSONFile(metaPath, &meta); err != nil {
+		t.Fatalf("read workbench metadata: %v", err)
+	}
+	meta.FingerprintInputs.ChangedFiles = append(meta.FingerprintInputs.ChangedFiles, "extra.go")
+	if err := writeJSONFile(metaPath, meta); err != nil {
+		t.Fatalf("write workbench metadata: %v", err)
+	}
+	_, deps3, err := selectionPromptInputFromArtifacts(result.Artifacts, result.Threads)
+	if err != nil {
+		t.Fatalf("selectionPromptInputFromArtifacts workbench change: %v", err)
+	}
+	if reflect.DeepEqual(deps2, deps3) {
+		t.Fatalf("deps after workbench metadata change = %#v, want changed from %#v", deps3, deps2)
+	}
+}
+
+func TestSelectionTaskMetadataDependsOnDossierSummaryTask(t *testing.T) {
+	ctx := context.Background()
+	store := openPipelineStore(t)
+	defer closeStore(t, store)
+	provider, req := dryRunHarness(t)
+	adapter := &llm.FakeAdapter{NameValue: "fake-llm"}
+	adapter.Queue(fakeLLMResult("dossier-summary-session", discussionSummaryJSON(nil, nil), 8, 2))
+	adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:reviewer", "main.go"), 10, 2))
+	adapter.Queue(fakeLLMResult("reviewer-session", findingsJSON("harness:reviewer", "main.go", "major", 2, "body"), 10, 2))
+	adapter.Queue(fakeLLMResult("rollup-session", rollupJSON("comment", []string{"finding-1"}), 10, 2))
+
+	result, err := dryRunForTest(ctx, Options{
+		Provider:        provider,
+		Adapter:         adapter,
+		Store:           store,
+		Layout:          statepaths.NewLayout(t.TempDir(), t.TempDir()),
+		Now:             fixedNow,
+		NewRunID:        func() string { return "run-selection-deps" },
+		NewSessionRowID: sequence("session"),
+		NewFindingID:    findingSequence("finding"),
+		NewActionID:     actionSequence(),
+		MaxConcurrency:  1,
+	}, req)
+	if err != nil {
+		t.Fatalf("DryRun: %v", err)
+	}
+	selectionMeta, ok, err := readLLMTaskMetadata(ArtifactPathsFromDir(result.Run.ArtifactPath), orchestratorSelectionStage)
+	if err != nil || !ok {
+		t.Fatalf("read selection metadata: ok=%v err=%v", ok, err)
+	}
+	if !reflect.DeepEqual(selectionMeta.DependencyTaskIDs, []string{dossierSummaryTaskID}) {
+		t.Fatalf("selection dependency_task_ids = %#v, want dossier summary dependency", selectionMeta.DependencyTaskIDs)
+	}
+}
+
+func TestRunSelectionPhaseRejectsStaleSelectionMetadataWhenDossierDigestChanges(t *testing.T) {
+	ctx := context.Background()
+	store := openPipelineStore(t)
+	defer closeStore(t, store)
+	layout := statepaths.NewLayout(t.TempDir(), t.TempDir())
+	run := allocatePipelineRun(t, store, layout, "run-selection-stale-dossier", ledger.PostModeDryRun, fixedNow())
+	provider, req := dryRunHarness(t)
+	adapter := &llm.FakeAdapter{NameValue: "fake-llm"}
+	adapter.Queue(fakeLLMResult("dossier-summary-session", discussionSummaryJSON(nil, nil), 8, 2))
+	adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:reviewer", "main.go"), 10, 2))
+	opts := Options{
+		Provider:        provider,
+		Adapter:         adapter,
+		Store:           store,
+		Layout:          layout,
+		Now:             fixedNow,
+		NewSessionRowID: sequence("session"),
+	}
+	configureWorkbenchFixtureForTest(ctx, &opts, req.PRRef)
+	prepared, err := prepareSelectionContext(ctx, opts, selectionSetupRequest{
+		PRRef:         req.PRRef,
+		Profile:       req.Profile,
+		AgentDirs:     req.AgentDirs,
+		ReviewBaseSHA: req.ReviewBaseSHA,
+		ReviewHeadSHA: req.ReviewHeadSHA,
+		ResolveArtifacts: func(gitprovider.PR) (ArtifactPaths, error) {
+			return ArtifactPathsFromDir(run.ArtifactPath), nil
+		},
+	})
+	if err != nil {
+		t.Fatalf("prepareSelectionContext: %v", err)
+	}
+	if err := prepareWorkbenchArtifacts(ctx, opts, workbenchPreparationRequest{
+		PRRef:        req.PRRef,
+		ReviewPR:     prepared.reviewPR,
+		ChangedFiles: prepared.changedFiles,
+		Artifacts:    prepared.artifacts,
+	}); err != nil {
+		t.Fatalf("prepareWorkbenchArtifacts: %v", err)
+	}
+	defer func() {
+		if err := unlockWorkbenchRepo(prepared.artifacts.WorkbenchRepoDir); err != nil {
+			t.Fatalf("unlockWorkbenchRepo: %v", err)
+		}
+	}()
+	if err := prepareDossierArtifacts(ctx, opts, dossierPreparationRequest{
+		RunID:     run.RunID,
+		Profile:   req.Profile,
+		Artifacts: prepared.artifacts,
+	}); err != nil {
+		t.Fatalf("prepareDossierArtifacts: %v", err)
+	}
+	if _, _, _, err := runSelectionPhase(ctx, opts, selectionPhaseRequest{
+		RunID:      run.RunID,
+		Profile:    req.Profile,
+		ReviewPR:   prepared.reviewPR,
+		Catalog:    prepared.catalog,
+		ParsedDiff: prepared.parsed,
+		Threads:    prepared.threads,
+		Artifacts:  prepared.artifacts,
+		MaxAgents:  1,
+	}); err != nil {
+		t.Fatalf("runSelectionPhase first: %v", err)
+	}
+	indexPath := prepared.artifacts.DossierIndexPath()
+	if err := os.WriteFile(indexPath, []byte(`{"hash_algorithm":"sha256","files":[{"path":"final/pr-intent.md","sha256":"changed"}]}`+"\n"), 0o600); err != nil {
+		t.Fatalf("WriteFile(%s): %v", indexPath, err)
+	}
+	secondAdapter := &llm.FakeAdapter{NameValue: "fake-llm"}
+	secondOpts := opts
+	secondOpts.Adapter = secondAdapter
+	_, _, _, err = runSelectionPhase(ctx, secondOpts, selectionPhaseRequest{
+		RunID:      run.RunID,
+		Profile:    req.Profile,
+		ReviewPR:   prepared.reviewPR,
+		Catalog:    prepared.catalog,
+		ParsedDiff: prepared.parsed,
+		Threads:    prepared.threads,
+		Artifacts:  prepared.artifacts,
+		MaxAgents:  1,
+	})
+	if err == nil || !strings.Contains(err.Error(), "input fingerprint changed") {
+		t.Fatalf("runSelectionPhase stale dossier error = %v, want input fingerprint changed", err)
+	}
+	if len(secondAdapter.Requests()) != 0 || len(secondAdapter.Resumes()) != 0 {
+		t.Fatalf("adapter invoked despite stale selection metadata: starts=%#v resumes=%#v", secondAdapter.Requests(), secondAdapter.Resumes())
+	}
 }
 
 func TestFindingsOutputContractScopesAnchorToFindingItems(t *testing.T) {
@@ -4027,10 +4284,10 @@ func TestDryRunContextBudgetFailures(t *testing.T) {
 		},
 		{
 			name:   "reviewer diff",
-			budget: 5000,
+			budget: 9500,
 			mutate: func(t *testing.T, provider *readOnlyProvider, _ *Request, _ *llm.FakeAdapter) {
 				t.Helper()
-				provider.diff.Raw = largeDiff("main.go", strings.Repeat("+var x = true\n", 400))
+				provider.diff.Raw = largeDiff("main.go", strings.Repeat("+var x = true\n", 1600))
 			},
 			queue: func(adapter *llm.FakeAdapter) {
 				adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:reviewer", "main.go"), 1, 1))
@@ -4040,7 +4297,7 @@ func TestDryRunContextBudgetFailures(t *testing.T) {
 		},
 		{
 			name:   "full content default model",
-			budget: 10000,
+			budget: 9500,
 			mutate: func(t *testing.T, provider *readOnlyProvider, req *Request, _ *llm.FakeAdapter) {
 				t.Helper()
 				dir := t.TempDir()
@@ -4075,30 +4332,6 @@ func TestDryRunContextBudgetFailures(t *testing.T) {
 			want:  "context budget exceeded for full-content agent harness:reviewer file main.go model bench-model",
 			runID: "run-budget-full-content-override",
 		},
-		{
-			name:   "rollup default model",
-			budget: 5000,
-			queue: func(adapter *llm.FakeAdapter) {
-				adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:reviewer", "main.go"), 1, 1))
-				adapter.Queue(fakeLLMResult("reviewer-session", findingsJSON("harness:reviewer", "main.go", "major", 2, strings.Repeat("body ", 1000)), 1, 1))
-			},
-			want:  "context budget exceeded for rollup model claude-sonnet-4-6",
-			runID: "run-budget-rollup-default",
-		},
-		{
-			name:   "rollup keeps default model under selection override",
-			budget: 5000,
-			mutate: func(t *testing.T, _ *readOnlyProvider, req *Request, _ *llm.FakeAdapter) {
-				t.Helper()
-				req.SelectionModelOverride = "bench-model"
-			},
-			queue: func(adapter *llm.FakeAdapter) {
-				adapter.Queue(fakeLLMResult("selection-session", selectionJSON("harness:reviewer", "main.go"), 1, 1))
-				adapter.Queue(fakeLLMResult("reviewer-session", findingsJSON("harness:reviewer", "main.go", "major", 2, strings.Repeat("body ", 1000)), 1, 1))
-			},
-			want:  "context budget exceeded for rollup model claude-sonnet-4-6",
-			runID: "run-budget-rollup-override",
-		},
 	}
 
 	for _, tt := range tests {
@@ -4137,6 +4370,39 @@ func TestDryRunContextBudgetFailures(t *testing.T) {
 	}
 }
 
+func TestRollupPromptBudgetUsesSynthesisModel(t *testing.T) {
+	provider, req := dryRunHarness(t)
+	rollupRuntime, err := resolveSynthesisRuntimeConfig(req)
+	if err != nil {
+		t.Fatalf("resolveSynthesisRuntimeConfig: %v", err)
+	}
+	prompt, err := buildRollupPrompt(provider.pr, largeRollupFindings(4, "main.go", strings.Repeat("body ", 4000)), nil)
+	if err != nil {
+		t.Fatalf("buildRollupPrompt: %v", err)
+	}
+	err = (Options{Budget: ContextBudget{MaxPromptBytes: 10000}}).checkPromptBudget("rollup", "", rollupRuntime.model, "", prompt)
+	if err == nil || !strings.Contains(err.Error(), "context budget exceeded for rollup model claude-sonnet-4-6") {
+		t.Fatalf("rollup budget error = %v, want synthesis-model budget failure", err)
+	}
+}
+
+func TestRollupPromptBudgetIgnoresSelectionModelOverride(t *testing.T) {
+	provider, req := dryRunHarness(t)
+	req.SelectionModelOverride = "bench-model"
+	rollupRuntime, err := resolveSynthesisRuntimeConfig(req)
+	if err != nil {
+		t.Fatalf("resolveSynthesisRuntimeConfig: %v", err)
+	}
+	prompt, err := buildRollupPrompt(provider.pr, largeRollupFindings(4, "main.go", strings.Repeat("body ", 4000)), nil)
+	if err != nil {
+		t.Fatalf("buildRollupPrompt: %v", err)
+	}
+	err = (Options{Budget: ContextBudget{MaxPromptBytes: 10000}}).checkPromptBudget("rollup", "", rollupRuntime.model, "", prompt)
+	if err == nil || !strings.Contains(err.Error(), "context budget exceeded for rollup model claude-sonnet-4-6") {
+		t.Fatalf("rollup budget error = %v, want default synthesis model despite selection override", err)
+	}
+}
+
 func TestSessionRowIDForFindingRequiresReviewerSession(t *testing.T) {
 	finding := reviewplan.AnchoredFinding{FindingID: "finding-1"}
 	if got, err := sessionRowIDForFinding(finding, map[review.FindingID]string{"finding-1": "session-1"}); err != nil || got != "session-1" {
@@ -4958,6 +5224,24 @@ func findingsJSON(agentID, file, severity string, line int, body string) string
 	return string(data)
 }
 
+func largeRollupFindings(count int, filePath, body string) []review.Finding {
+	out := make([]review.Finding, 0, count)
+	for i := 0; i < count; i++ {
+		out = append(out, review.Finding{
+			ID:       review.FindingID(fmt.Sprintf("finding-%d", i+1)),
+			Severity: review.SeverityMajor,
+			FilePath: filePath,
+			Anchor: review.Anchor{
+				Kind: review.AnchorKindLine,
+				Side: review.DiffSideRight,
+				Line: i + 2,
+			},
+			Body: body,
+		})
+	}
+	return out
+}
+
 func findingsFileAliasJSON(agentID, file, severity string, line int, body string) string {
 	payload := map[string]any{
 		"schema_version": 1,
@@ -5323,7 +5607,6 @@ func assertPromptOmitsLocalAgentSourceProvenance(t *testing.T, prompt string, so
 	for _, forbidden := range []string{
 		"configured_path",
 		"canonical_path",
-		"fingerprint",
 		"Source warning",
 		"OS temp directory",
 		"Git worktree",