diff --git a/CONTEXT.md b/CONTEXT.md
new file mode 100644
index 0000000..da301fe
--- /dev/null
+++ b/CONTEXT.md
@@ -0,0 +1,61 @@
+# SourceOS
+
+SourceOS is a personal operating system for turning traceable reality signals into product decisions. Its language separates evidence from claims and bounded agent action from operator authority.
+
+## Agent Operation
+
+**Discovery Agent**:
+The bounded actor that plans and performs approved public-source collection, then returns traceable evidence, counterevidence, unknowns, and a proposed next action. It never makes product, commercial, or external-contact decisions.
+_Avoid_: autonomous founder, full agent, chat assistant
+
+**Operator Approval**:
+The explicit decision by the operator that permits an action outside the Discovery Agent's approved source, tool, or budget boundary.
+_Avoid_: confirmation, consent, automatic escalation
+
+**Approved Collection Boundary**:
+The versioned set of public sources, tools, request, time, and cost limits within which a Discovery Agent may act without a new Operator Approval.
+_Avoid_: agent permission, unrestricted access
+
+**Discovery Objective**:
+The operator-owned, falsifiable question that gives a Discovery Agent a continuing reason to learn until its stop condition, pause, or budget limit is reached.
+_Avoid_: project, research task, agent prompt
+
+**Acquisition Plan**:
+A versioned proposal from a Discovery Agent that states how one Discovery Objective should next be investigated, including sources, hypotheses, counterevidence targets, and bounded runs.
+_Avoid_: mission, schedule, crawl configuration
+
+**Plan Revision**:
+A recorded change from one Acquisition Plan version to another that names the evidence or coverage gap responsible for the change. A revision may only use the current Approved Collection Boundary.
+_Avoid_: retuning, silent optimization, agent learning
+
+**Discovery Assessment**:
+A versioned, evidence-cited Agent judgement about an Objective's support, counterevidence, unknowns, coverage gaps, and recommended next plan. It is not a business decision.
+_Avoid_: answer, conclusion, validated result
+
+**Need Hypothesis**:
+An Agent-drafted, falsifiable explanation of a possible unmet need that awaits operator promotion to a Need Issue.
+_Avoid_: discovered need, validated demand, product opportunity
+
+**Blocked Assessment**:
+A Discovery Assessment that states the Agent cannot produce a defensible next plan within the remaining evidence, boundary, and budget, and names the missing information or approval.
+_Avoid_: failure, no result, keep researching
+
+**Outcome Feedback**:
+Observed tracking, delivery, retention, payment, refund, or support results from a product or service that the Discovery Agent may read to calibrate future discovery. It does not authorize the Agent to execute product or commercial actions.
+_Avoid_: Agent action, market proof by itself
+
+**Discovery Objective Workspace**:
+The operator interface for one Discovery Objective, presenting its stop conditions, current Assessment, plan revisions, bounded runs, evidence, and approval decisions. It is not a chat-first interface.
+_Avoid_: dashboard, task board, agent chat
+
+**Discovery Decision Record**:
+The closing record for a Discovery Objective, stating its decision state, cited support and counterevidence, resource use, unresolved unknowns, and later Outcome Feedback. It is the unit through which discovery quality is revisited.
+_Avoid_: agent score, success metric, final answer
+
+**Acquisition Mission**:
+A concrete, approved collection instruction within one Acquisition Plan; it directs a bounded run and is not evidence or a demand claim.
+_Avoid_: discovery objective, task, crawl job
+
+**Evidence Candidate**:
+Traceable collected material awaiting operator triage; its existence does not establish a Need Issue or product demand.
+_Avoid_: validated insight, discovered need
diff --git a/apps/api/main.py b/apps/api/main.py
index bc51f2e..307016f 100644
--- a/apps/api/main.py
+++ b/apps/api/main.py
@@ -15,6 +15,7 @@
     acquisition_missions,
     agent_runs,
     delivery_records,
+    discovery_objectives,
     experiments,
     export,
     external_signals,
@@ -90,6 +91,11 @@ async def lifespan(app: FastAPI):
 app.include_router(export.router, prefix="/api/export", tags=["Export"])
 app.include_router(need_issues.router, prefix="/api/need-issues", tags=["Need Issues"])
 app.include_router(agent_runs.router, prefix="/api/agent-runs", tags=["Agent Runs"])
+app.include_router(
+    agent_runs.objective_router,
+    prefix="/api/discovery-objectives",
+    tags=["Discovery Agent Runs"],
+)
 app.include_router(experiments.router, prefix="/api/experiments", tags=["Validation Experiments"])
 app.include_router(product_theses.router, prefix="/api/product-theses", tags=["Product Theses"])
 app.include_router(features.router, prefix="/api/features", tags=["Feature Definitions"])
@@ -100,6 +106,11 @@ async def lifespan(app: FastAPI):
     feature_outcomes.router, prefix="/api/feature-outcomes", tags=["Feature Outcomes"]
 )
 app.include_router(today.router, prefix="/api/today", tags=["Today"])
+app.include_router(
+    discovery_objectives.router,
+    prefix="/api/discovery-objectives",
+    tags=["Discovery Objectives"],
+)
 app.include_router(
     ontology_hypotheses.router, prefix="/api/ontology-hypotheses", tags=["Ontology Hypotheses"]
 )
diff --git a/apps/api/routers/acquisition_mission_runs.py b/apps/api/routers/acquisition_mission_runs.py
index 962a62f..1a932fb 100644
--- a/apps/api/routers/acquisition_mission_runs.py
+++ b/apps/api/routers/acquisition_mission_runs.py
@@ -38,6 +38,11 @@
 from packages.storage.models.acquisition_mission_run_signal import (
     AcquisitionMissionRunSignal,
 )
+from packages.storage.models.acquisition_plan import AcquisitionPlan
+from packages.storage.models.discovery_objective import (
+    ApprovedCollectionBoundary,
+    DiscoveryObjective,
+)
 from packages.storage.models.external_signal import ExternalSignal
 from packages.storage.models.source import Source
 
@@ -57,6 +62,26 @@ async def _get_mission_or_404(db: AsyncSession, mission_id: uuid.UUID) -> Acquis
         raise HTTPException(
             status_code=422, detail="Acquisition Mission has no pinned source version"
         )
+    if mission.acquisition_plan_id is not None:
+        plan = await db.get(AcquisitionPlan, mission.acquisition_plan_id)
+        if plan is None:
+            raise HTTPException(status_code=409, detail="Mission Plan is no longer available")
+        objective = await db.get(DiscoveryObjective, plan.objective_id)
+        current_boundary = await db.scalar(
+            select(ApprovedCollectionBoundary)
+            .where(ApprovedCollectionBoundary.objective_id == plan.objective_id)
+            .order_by(ApprovedCollectionBoundary.version.desc())
+        )
+        if (
+            objective is None
+            or objective.status != "active"
+            or current_boundary is None
+            or plan.boundary_id != current_boundary.id
+        ):
+            raise HTTPException(
+                status_code=409,
+                detail="Plan is no longer permitted by the current approved boundary",
+            )
     return mission
 
 
@@ -88,6 +113,7 @@ async def _persist_signal_drafts(
                 {
                     "id": uuid.uuid4(),
                     "mission_run_id": run.id,
+                    "source_id": uuid.UUID(run.input_snapshot["source"]["id"]),
                     "lineage_key": draft.lineage_key,
                     "raw_artifact_key": draft.raw_artifact_key,
                     "source_label": draft.source_label,
diff --git a/apps/api/routers/acquisition_missions.py b/apps/api/routers/acquisition_missions.py
index 7fc6303..048609d 100644
--- a/apps/api/routers/acquisition_missions.py
+++ b/apps/api/routers/acquisition_missions.py
@@ -15,6 +15,11 @@
     AcquisitionMissionResponse,
 )
 from packages.storage.models.acquisition_mission import AcquisitionMission
+from packages.storage.models.acquisition_plan import AcquisitionPlan
+from packages.storage.models.discovery_objective import (
+    ApprovedCollectionBoundary,
+    DiscoveryObjective,
+)
 from packages.storage.models.source_config_version import SourceConfigVersion
 
 router = APIRouter()
@@ -55,6 +60,29 @@ async def create_acquisition_mission(
             ),
         )
 
+    if body.acquisition_plan_id is not None:
+        plan = await db.scalar(
+            select(AcquisitionPlan).where(AcquisitionPlan.id == body.acquisition_plan_id)
+        )
+        if plan is None or str(body.source_id) not in plan.selected_source_ids:
+            raise HTTPException(
+                status_code=422,
+                detail="Mission source is not selected by the plan",
+            )
+        objective = await db.scalar(
+            select(DiscoveryObjective).where(DiscoveryObjective.id == plan.objective_id)
+        )
+        current_boundary = await db.scalar(
+            select(ApprovedCollectionBoundary)
+            .where(ApprovedCollectionBoundary.objective_id == plan.objective_id)
+            .order_by(ApprovedCollectionBoundary.version.desc())
+        )
+        if objective.status != "active" or plan.boundary_id != current_boundary.id:
+            raise HTTPException(
+                status_code=409,
+                detail="Plan is no longer permitted by the current approved boundary",
+            )
+
     mission = AcquisitionMission(
         **body.model_dump(),
         source_config_version=config,
diff --git a/apps/api/routers/agent_runs.py b/apps/api/routers/agent_runs.py
index 7a5bd1d..80e5040 100644
--- a/apps/api/routers/agent_runs.py
+++ b/apps/api/routers/agent_runs.py
@@ -1,5 +1,6 @@
 """Run deterministic proposal agents against an immutable evidence bundle."""
 
+import asyncio
 import hashlib
 import json
 import uuid
@@ -13,13 +14,65 @@
 from apps.api.dependencies import get_db
 from apps.api.schemas.agent_run import AgentRunCreate, AgentRunOperatorDecision, AgentRunResponse
 from apps.api.services.pi_runtime import PiRuntimeError, run_pi_proposal
+from packages.storage.models.acquisition_plan import AcquisitionPlan
 from packages.storage.models.agent_run import AgentRun
+from packages.storage.models.discovery_objective import (
+    ApprovedCollectionBoundary,
+    DiscoveryObjective,
+)
 from packages.storage.models.external_signal import ExternalSignal
 
 router = APIRouter()
+objective_router = APIRouter()
 _TOOL_ALLOWLIST: list[str] = []
 
 
+def _objective_input_context(
+    objective: DiscoveryObjective,
+    boundary: ApprovedCollectionBoundary,
+    plan: AcquisitionPlan | None,
+    proposal_type: str,
+) -> dict:
+    """Freeze the read-only Objective and Boundary the Agent was allowed to see."""
+    return {
+        "objective": {
+            "id": str(objective.id),
+            "title": objective.title,
+            "question": objective.question,
+            "status": objective.status,
+            "resource_stop_conditions": objective.resource_stop_conditions,
+            "evidence_stop_conditions": objective.evidence_stop_conditions,
+            "decision_stop_conditions": objective.decision_stop_conditions,
+        },
+        "boundary": {
+            "id": str(boundary.id),
+            "version": boundary.version,
+            "approved_source_ids": boundary.approved_source_ids,
+            "tool_allowlist": boundary.tool_allowlist,
+            "request_limit": boundary.request_limit,
+            "time_budget_minutes": boundary.time_budget_minutes,
+            "cost_budget_cents": boundary.cost_budget_cents,
+            "credential_scope": boundary.credential_scope,
+            "evidence_conditions": boundary.evidence_conditions,
+        },
+        "plan": (
+            {
+                "id": str(plan.id),
+                "version": plan.version,
+                "question": plan.question,
+                "selected_source_ids": plan.selected_source_ids,
+                "counterevidence_target": plan.counterevidence_target,
+                "request_budget": plan.request_budget,
+                "time_budget_minutes": plan.time_budget_minutes,
+                "cost_budget_cents": plan.cost_budget_cents,
+            }
+            if plan is not None
+            else None
+        ),
+        "proposal_type": proposal_type,
+    }
+
+
 async def _run_or_404(db: AsyncSession, run_id: uuid.UUID) -> AgentRun:
     run = await db.get(AgentRun, run_id)
     if run is None:
@@ -27,11 +80,91 @@ async def _run_or_404(db: AsyncSession, run_id: uuid.UUID) -> AgentRun:
     return run
 
 
-def _bundle_hash(bundle: list[dict]) -> str:
+def _bundle_hash(bundle: object) -> str:
     encoded = json.dumps(bundle, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
     return hashlib.sha256(encoded.encode()).hexdigest()
 
 
+def _structured_assessment_proposal(runtime_output: dict, evidence_ids: list[str]) -> dict:
+    """Expose a stable proposal contract; malformed model text becomes an explicit unknown."""
+    fallback = {
+        "contract": "discovery_assessment_proposal.v1",
+        "kind": "unknown",
+        "statement": "The Agent output cannot support an assessment proposal yet.",
+        "evidence_ids": evidence_ids,
+        "assessment_ids": [],
+        "unknowns": ["Pi output did not satisfy the assessment proposal contract."],
+        "coverage_gaps": [],
+        "recommendation": "Review the cited evidence or run a bounded next acquisition plan.",
+        "status": "unknown",
+    }
+    try:
+        raw = json.loads(str(runtime_output.get("raw_output", "")))
+    except json.JSONDecodeError:
+        return fallback
+    allowed_kinds = {
+        "support",
+        "counterevidence",
+        "unknown",
+        "coverage_gap",
+        "blocked",
+        "recommendation",
+    }
+    if (
+        not isinstance(raw, dict)
+        or raw.get("kind") not in allowed_kinds
+        or not isinstance(raw.get("statement"), str)
+        or not raw["statement"].strip()
+        or not isinstance(raw.get("unknowns", []), list)
+    ):
+        return fallback
+    cited_ids = raw.get("evidence_ids", evidence_ids)
+    if not isinstance(cited_ids, list) or set(cited_ids) - set(evidence_ids):
+        return fallback
+    return {
+        "contract": "discovery_assessment_proposal.v1",
+        "kind": raw["kind"],
+        "statement": raw["statement"].strip(),
+        "evidence_ids": cited_ids,
+        "assessment_ids": [],
+        "unknowns": raw.get("unknowns", []),
+        "coverage_gaps": raw.get("coverage_gaps", []),
+        "recommendation": raw.get("recommendation"),
+        "status": "proposed",
+    }
+
+
+def _structured_plan_revision_proposal(runtime_output: dict, plan: dict) -> dict:
+    """A malformed plan recommendation never becomes a runnable Plan Revision."""
+    fallback = {
+        "contract": "acquisition_plan_revision_proposal.v1",
+        "predecessor_plan_id": plan["id"],
+        "proposed_delta": {},
+        "reason": "Pi output cannot support a Plan Revision proposal yet.",
+        "coverage_gaps": ["Pi output did not satisfy the plan revision contract."],
+        "status": "unknown",
+    }
+    try:
+        raw = json.loads(str(runtime_output.get("raw_output", "")))
+    except json.JSONDecodeError:
+        return fallback
+    if (
+        not isinstance(raw, dict)
+        or not isinstance(raw.get("proposed_delta"), dict)
+        or not isinstance(raw.get("reason"), str)
+        or not raw["reason"].strip()
+    ):
+        return fallback
+    return {
+        "contract": "acquisition_plan_revision_proposal.v1",
+        "predecessor_plan_id": plan["id"],
+        "proposed_delta": raw["proposed_delta"],
+        "reason": raw["reason"].strip(),
+        "coverage_gaps": raw.get("coverage_gaps", []),
+        "status": "proposed",
+    }
+
+
 @router.get("/{run_id}", response_model=AgentRunResponse)
 async def get_agent_run(run_id: uuid.UUID, db: Annotated[AsyncSession, Depends(get_db)]):
     return await _run_or_404(db, run_id)
@@ -43,10 +176,20 @@ async def create_agent_run(
     response: Response,
     db: Annotated[AsyncSession, Depends(get_db)],
 ):
+    if body.acquisition_plan_id is not None or body.proposal_type == "plan_revision":
+        raise HTTPException(
+            status_code=422,
+            detail="A plan-bound Agent Run must use a Discovery Objective endpoint",
+        )
     existing = await db.scalar(
         select(AgentRun).where(AgentRun.idempotency_key == body.idempotency_key)
     )
     if existing is not None:
+        if existing.objective_id is not None:
+            raise HTTPException(
+                status_code=409,
+                detail="Agent Run idempotency key belongs to a Discovery Objective",
+            )
         response.status_code = 200
         return existing
     signals = list(
@@ -78,6 +221,7 @@ async def create_agent_run(
             "max_tool_calls": body.max_tool_calls,
             "max_tokens": body.max_tokens,
             "max_cost_cents": body.max_cost_cents,
+            "max_time_minutes": body.max_time_minutes,
         },
         tool_allowlist=_TOOL_ALLOWLIST,
         tool_audit=[],
@@ -92,6 +236,125 @@ async def create_agent_run(
     return run
 
 
+@objective_router.post(
+    "/{objective_id}/agent-runs", response_model=AgentRunResponse, status_code=201
+)
+async def create_objective_agent_run(
+    objective_id: uuid.UUID,
+    body: AgentRunCreate,
+    response: Response,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.get(DiscoveryObjective, objective_id)
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    if objective.status != "active":
+        raise HTTPException(
+            status_code=409, detail="Only an active objective can run the Discovery Agent"
+        )
+    boundary = await db.scalar(
+        select(ApprovedCollectionBoundary)
+        .where(ApprovedCollectionBoundary.objective_id == objective_id)
+        .order_by(ApprovedCollectionBoundary.version.desc())
+    )
+    if (
+        body.max_tool_calls > boundary.request_limit
+        or body.max_cost_cents > boundary.cost_budget_cents
+        or body.max_time_minutes > boundary.time_budget_minutes
+    ):
+        raise HTTPException(status_code=422, detail="Agent budget is outside the approved boundary")
+    existing = await db.scalar(
+        select(AgentRun).where(AgentRun.idempotency_key == body.idempotency_key)
+    )
+    if existing is not None:
+        if existing.objective_id != objective_id:
+            raise HTTPException(
+                status_code=409,
+                detail="Agent Run idempotency key belongs to another Objective",
+            )
+        response.status_code = 200
+        return existing
+    plan = None
+    if body.acquisition_plan_id is not None:
+        plan = await db.scalar(
+            select(AcquisitionPlan).where(AcquisitionPlan.id == body.acquisition_plan_id)
+        )
+        if plan is None or plan.objective_id != objective_id or plan.boundary_id != boundary.id:
+            raise HTTPException(
+                status_code=422,
+                detail="Agent Run plan is outside this Objective's current boundary",
+            )
+    elif body.proposal_type == "plan_revision":
+        raise HTTPException(
+            status_code=422,
+            detail="A plan revision proposal requires an Acquisition Plan",
+        )
+    signals = list(
+        await db.scalars(
+            select(ExternalSignal).where(ExternalSignal.id.in_(body.evidence_signal_ids))
+        )
+    )
+    if len(signals) != len(body.evidence_signal_ids):
+        raise HTTPException(status_code=422, detail="Every evidence signal must exist")
+    approved_source_ids = set(boundary.approved_source_ids)
+    if any(
+        signal.source_id is None or str(signal.source_id) not in approved_source_ids
+        for signal in signals
+    ):
+        raise HTTPException(
+            status_code=422,
+            detail="Every evidence signal must belong to the current approved boundary",
+        )
+    if plan is not None and any(
+        str(signal.source_id) not in set(plan.selected_source_ids) for signal in signals
+    ):
+        raise HTTPException(
+            status_code=422,
+            detail="Every evidence signal must belong to the Agent Run's Acquisition Plan",
+        )
+    bundle = [
+        {
+            "signal_id": str(signal.id),
+            "source_id": str(signal.source_id),
+            "source_label": signal.source_label,
+            "source_uri": signal.source_uri,
+            "original_material": signal.original_material,
+            "observation": signal.observation,
+        }
+        for signal in signals
+    ]
+    input_context = _objective_input_context(objective, boundary, plan, body.proposal_type)
+    run = AgentRun(
+        objective_id=objective_id,
+        boundary_id=boundary.id,
+        boundary_version=boundary.version,
+        acquisition_plan_id=plan.id if plan is not None else None,
+        input_context=input_context,
+        idempotency_key=body.idempotency_key,
+        task_instruction=body.task_instruction,
+        evidence_bundle=bundle,
+        evidence_bundle_hash=_bundle_hash({"input_context": input_context, "evidence": bundle}),
+        model_version=body.model_version,
+        prompt_version=body.prompt_version,
+        budgets={
+            "max_tool_calls": body.max_tool_calls,
+            "max_tokens": body.max_tokens,
+            "max_cost_cents": body.max_cost_cents,
+            "max_time_minutes": body.max_time_minutes,
+        },
+        tool_allowlist=boundary.tool_allowlist,
+        tool_audit=[],
+        usage={"tool_calls": 0, "tokens": 0, "cost_cents": 0},
+        errors=[],
+        operator_changes=[],
+        status="created",
+    )
+    db.add(run)
+    await db.commit()
+    await db.refresh(run)
+    return run
+
+
 @router.post("/{run_id}/execute", response_model=AgentRunResponse)
 async def execute_agent_run(run_id: uuid.UUID, db: Annotated[AsyncSession, Depends(get_db)]):
     run = await _run_or_404(db, run_id)
@@ -99,16 +362,51 @@ async def execute_agent_run(run_id: uuid.UUID, db: Annotated[AsyncSession, Depen
         raise HTTPException(status_code=409, detail="Cancelled Agent Run cannot execute")
     if run.status == "completed":
         return run
-    try:
-        runtime_output = await run_pi_proposal(
-            run_id=str(run.id),
-            task_instruction=run.task_instruction,
-            evidence_bundle_hash=run.evidence_bundle_hash,
-            evidence_bundle=run.evidence_bundle,
-            model_version=run.model_version,
-            budgets=run.budgets,
+    if run.objective_id is not None:
+        objective = await db.get(DiscoveryObjective, run.objective_id)
+        current_boundary = await db.scalar(
+            select(ApprovedCollectionBoundary)
+            .where(ApprovedCollectionBoundary.objective_id == run.objective_id)
+            .order_by(ApprovedCollectionBoundary.version.desc())
         )
+        if (
+            objective is None
+            or objective.status != "active"
+            or current_boundary is None
+            or current_boundary.id != run.boundary_id
+            or current_boundary.version != run.boundary_version
+        ):
+            raise HTTPException(
+                status_code=409,
+                detail="Discovery Agent run boundary is no longer active",
+            )
+    try:
+        async with asyncio.timeout(run.budgets.get("max_time_minutes", 1) * 60):
+            runtime_output = await run_pi_proposal(
+                run_id=str(run.id),
+                task_instruction=run.task_instruction,
+                evidence_bundle_hash=run.evidence_bundle_hash,
+                evidence_bundle=(
+                    [
+                        *run.evidence_bundle,
+                        {"kind": "objective_context", "snapshot": run.input_context},
+                    ]
+                    if run.input_context is not None
+                    else run.evidence_bundle
+                ),
+                model_version=run.model_version,
+                budgets=run.budgets,
+            )
         runtime_usage = runtime_output.pop("usage", {})
+        if run.objective_id is not None:
+            runtime_output["proposal"] = (
+                _structured_plan_revision_proposal(runtime_output, run.input_context["plan"])
+                if run.input_context.get("proposal_type") == "plan_revision"
+                else _structured_assessment_proposal(
+                    runtime_output,
+                    [entry["signal_id"] for entry in run.evidence_bundle],
+                )
+            )
         run.output = runtime_output
         run.tool_audit = [
             {"tool": "Pi Agent", "status": "completed", "policy": "no executable tools"}
@@ -119,7 +417,7 @@ async def execute_agent_run(run_id: uuid.UUID, db: Annotated[AsyncSession, Depen
             "cost_cents": runtime_usage.get("cost_cents", 0),
         }
         run.status = "completed"
-    except PiRuntimeError as error:
+    except (PiRuntimeError, TimeoutError) as error:
         run.errors = [*run.errors, {"stage": "runtime", "error": str(error)}]
         run.status = "failed"
     run.completed_at = datetime.now(UTC)
diff --git a/apps/api/routers/discovery_objectives.py b/apps/api/routers/discovery_objectives.py
new file mode 100644
index 0000000..103f9c3
--- /dev/null
+++ b/apps/api/routers/discovery_objectives.py
@@ -0,0 +1,816 @@
+"""Create and read operator-bounded Discovery Objectives."""
+
+import uuid
+from datetime import UTC, datetime
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from apps.api.dependencies import get_db
+from apps.api.routers.need_issues import create_need_issue_from_accepted_signal
+from apps.api.schemas.acquisition_mission_run import AcquisitionMissionRunResponse
+from apps.api.schemas.agent_run import AgentRunResponse
+from apps.api.schemas.discovery_objective import (
+    AcquisitionPlanCreate,
+    AcquisitionPlanResponse,
+    ApprovedCollectionBoundaryResponse,
+    BoundaryPatch,
+    DecisionRecordCreate,
+    DiscoveryAssessmentCreate,
+    DiscoveryAssessmentResponse,
+    DiscoveryDecisionRecordResponse,
+    DiscoveryObjectiveCreate,
+    DiscoveryObjectiveResponse,
+    DiscoveryObjectiveWorkspaceResponse,
+    NeedHypothesisCreate,
+    NeedHypothesisPromotion,
+    NeedHypothesisResponse,
+    ObjectiveBlockRequest,
+    OperatorApprovalCreate,
+    OperatorApprovalDecision,
+    OperatorApprovalResponse,
+    OperatorBoundaryRevisionCreate,
+    OperatorBoundaryRevisionResponse,
+    OutcomeFeedbackCreate,
+    OutcomeFeedbackResponse,
+    PlanRevisionResponse,
+)
+from apps.api.schemas.need_issue import NeedIssueFromAcceptedSignalCreate
+from packages.storage.models.acquisition_mission_run import AcquisitionMissionRun
+from packages.storage.models.acquisition_plan import AcquisitionPlan, PlanRevision
+from packages.storage.models.agent_run import AgentRun
+from packages.storage.models.discovery_assessment import DiscoveryAssessment, NeedHypothesis
+from packages.storage.models.discovery_decision import DiscoveryDecisionRecord, OutcomeFeedback
+from packages.storage.models.discovery_objective import (
+    ApprovedCollectionBoundary,
+    DiscoveryObjective,
+    OperatorApproval,
+    OperatorBoundaryRevision,
+)
+from packages.storage.models.external_signal import ExternalSignal
+from packages.storage.models.source import Source
+
+router = APIRouter()
+
+
+def _objective_with_boundaries(objective_id: uuid.UUID):
+    return (
+        select(DiscoveryObjective)
+        .options(selectinload(DiscoveryObjective.boundaries))
+        .where(DiscoveryObjective.id == objective_id)
+    )
+
+
+def _plan_with_missions(plan_id: uuid.UUID):
+    return (
+        select(AcquisitionPlan)
+        .options(selectinload(AcquisitionPlan.missions))
+        .where(AcquisitionPlan.id == plan_id)
+    )
+
+
+def _response_for(objective: DiscoveryObjective) -> DiscoveryObjectiveResponse:
+    current_boundary = objective.boundaries[-1]
+    return DiscoveryObjectiveResponse(
+        id=objective.id,
+        title=objective.title,
+        question=objective.question,
+        resource_stop_conditions=objective.resource_stop_conditions,
+        evidence_stop_conditions=objective.evidence_stop_conditions,
+        decision_stop_conditions=objective.decision_stop_conditions,
+        status=objective.status,
+        created_at=objective.created_at,
+        updated_at=objective.updated_at,
+        current_boundary=ApprovedCollectionBoundaryResponse.model_validate(current_boundary),
+    )
+
+
+def _boundary_response(boundary: ApprovedCollectionBoundary) -> ApprovedCollectionBoundaryResponse:
+    return ApprovedCollectionBoundaryResponse.model_validate(boundary)
+
+
+def _revision_response(
+    revision: OperatorBoundaryRevision, boundary_version: int
+) -> OperatorBoundaryRevisionResponse:
+    return OperatorBoundaryRevisionResponse(
+        id=revision.id,
+        objective_id=revision.objective_id,
+        boundary_id=revision.boundary_id,
+        boundary_version=boundary_version,
+        approval_id=revision.approval_id,
+        operator=revision.operator,
+        reason=revision.reason,
+        boundary_patch=revision.boundary_patch,
+        created_at=revision.created_at,
+    )
+
+
+async def _plan_response(db: AsyncSession, plan: AcquisitionPlan) -> AcquisitionPlanResponse:
+    revision = await db.scalar(select(PlanRevision).where(PlanRevision.plan_id == plan.id))
+    boundary = await db.scalar(
+        select(ApprovedCollectionBoundary).where(ApprovedCollectionBoundary.id == plan.boundary_id)
+    )
+    mission_ids = [mission.id for mission in plan.missions]
+    runs = (
+        list(
+            (
+                await db.scalars(
+                    select(AcquisitionMissionRun)
+                    .where(AcquisitionMissionRun.mission_id.in_(mission_ids))
+                    .order_by(AcquisitionMissionRun.started_at.desc())
+                )
+            ).all()
+        )
+        if mission_ids
+        else []
+    )
+    mission_runs: dict[uuid.UUID, list[AcquisitionMissionRunResponse]] = {
+        mission_id: [] for mission_id in mission_ids
+    }
+    for run in runs:
+        mission_runs[run.mission_id].append(AcquisitionMissionRunResponse.model_validate(run))
+    return AcquisitionPlanResponse(
+        id=plan.id,
+        objective_id=plan.objective_id,
+        boundary_id=plan.boundary_id,
+        boundary_version=boundary.version,
+        version=plan.version,
+        question=plan.question,
+        selected_source_ids=plan.selected_source_ids,
+        counterevidence_target=plan.counterevidence_target,
+        request_budget=plan.request_budget,
+        time_budget_minutes=plan.time_budget_minutes,
+        cost_budget_cents=plan.cost_budget_cents,
+        created_at=plan.created_at,
+        predecessor_plan_id=revision.predecessor_plan_id if revision else None,
+        revision=(
+            PlanRevisionResponse(
+                id=revision.id,
+                predecessor_plan_id=revision.predecessor_plan_id,
+                reason=revision.reason,
+                delta=revision.delta,
+                created_at=revision.created_at,
+            )
+            if revision
+            else None
+        ),
+        missions=mission_ids,
+        mission_runs=mission_runs,
+    )
+
+
+async def _decision_record_response(
+    db: AsyncSession, record: DiscoveryDecisionRecord
+) -> DiscoveryDecisionRecordResponse:
+    outcomes = list(
+        (
+            await db.scalars(
+                select(OutcomeFeedback)
+                .where(OutcomeFeedback.decision_record_id == record.id)
+                .order_by(OutcomeFeedback.created_at)
+            )
+        ).all()
+    )
+    return DiscoveryDecisionRecordResponse(
+        id=record.id,
+        objective_id=record.objective_id,
+        decision=record.decision,
+        reason=record.reason,
+        support_assessment_ids=record.support_assessment_ids,
+        counter_assessment_ids=record.counter_assessment_ids,
+        unknowns=record.unknowns,
+        resource_usage=record.resource_usage,
+        created_at=record.created_at,
+        outcomes=[OutcomeFeedbackResponse.model_validate(outcome) for outcome in outcomes],
+    )
+
+
+async def _validate_source_ids(db: AsyncSession, source_ids: list[uuid.UUID]) -> None:
+    if len(set(source_ids)) != len(source_ids):
+        raise HTTPException(status_code=422, detail="Approved source IDs must not repeat")
+    found_source_ids = set(
+        (await db.scalars(select(Source.id).where(Source.id.in_(source_ids)))).all()
+    )
+    if found_source_ids != set(source_ids):
+        raise HTTPException(status_code=422, detail="An approved source does not exist")
+
+
+async def _apply_boundary_patch(
+    db: AsyncSession,
+    objective: DiscoveryObjective,
+    current: ApprovedCollectionBoundary,
+    patch: BoundaryPatch,
+) -> tuple[ApprovedCollectionBoundary, dict]:
+    values = patch.model_dump(exclude_none=True)
+    if not values:
+        raise HTTPException(status_code=422, detail="Boundary revision requires a material delta")
+    if "approved_source_ids" in values:
+        await _validate_source_ids(db, values["approved_source_ids"])
+        values["approved_source_ids"] = [
+            str(source_id) for source_id in values["approved_source_ids"]
+        ]
+
+    current_values = {
+        "approved_source_ids": current.approved_source_ids,
+        "tool_allowlist": current.tool_allowlist,
+        "request_limit": current.request_limit,
+        "time_budget_minutes": current.time_budget_minutes,
+        "cost_budget_cents": current.cost_budget_cents,
+        "credential_scope": current.credential_scope,
+        "evidence_conditions": current.evidence_conditions,
+    }
+    if all(current_values[key] == value for key, value in values.items()):
+        raise HTTPException(status_code=422, detail="Boundary revision must change an allowance")
+
+    next_values = current_values | values
+    boundary = ApprovedCollectionBoundary(
+        objective=objective,
+        version=current.version + 1,
+        **next_values,
+    )
+    db.add(boundary)
+    await db.flush()
+    return boundary, values
+
+
+@router.post("", response_model=DiscoveryObjectiveResponse, status_code=201)
+async def create_discovery_objective(
+    body: DiscoveryObjectiveCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    source_ids = body.initial_boundary.approved_source_ids
+    await _validate_source_ids(db, source_ids)
+
+    objective = DiscoveryObjective(
+        title=body.title,
+        question=body.question,
+        resource_stop_conditions=body.resource_stop_conditions,
+        evidence_stop_conditions=body.evidence_stop_conditions,
+        decision_stop_conditions=body.decision_stop_conditions,
+    )
+    boundary = ApprovedCollectionBoundary(
+        objective=objective,
+        version=1,
+        approved_source_ids=[str(source_id) for source_id in source_ids],
+        tool_allowlist=body.initial_boundary.tool_allowlist,
+        request_limit=body.initial_boundary.request_limit,
+        time_budget_minutes=body.initial_boundary.time_budget_minutes,
+        cost_budget_cents=body.initial_boundary.cost_budget_cents,
+        credential_scope=body.initial_boundary.credential_scope,
+        evidence_conditions=body.initial_boundary.evidence_conditions,
+    )
+    db.add_all([objective, boundary])
+    await db.commit()
+    saved = await db.scalar(_objective_with_boundaries(objective.id))
+    return _response_for(saved)
+
+
+@router.get("/{objective_id}", response_model=DiscoveryObjectiveResponse)
+async def get_discovery_objective(
+    objective_id: uuid.UUID,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(_objective_with_boundaries(objective_id))
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    return _response_for(objective)
+
+
+@router.get("/{objective_id}/workspace", response_model=DiscoveryObjectiveWorkspaceResponse)
+async def get_discovery_objective_workspace(
+    objective_id: uuid.UUID,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(_objective_with_boundaries(objective_id))
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    response = _response_for(objective)
+    plans = list(
+        (
+            await db.scalars(
+                select(AcquisitionPlan)
+                .options(selectinload(AcquisitionPlan.missions))
+                .where(AcquisitionPlan.objective_id == objective_id)
+                .order_by(AcquisitionPlan.version.desc())
+            )
+        ).all()
+    )
+    decision_record = await db.scalar(
+        select(DiscoveryDecisionRecord).where(DiscoveryDecisionRecord.objective_id == objective_id)
+    )
+    agent_runs = list(
+        (
+            await db.scalars(
+                select(AgentRun)
+                .where(AgentRun.objective_id == objective_id)
+                .order_by(AgentRun.created_at.desc())
+            )
+        ).all()
+    )
+    evidence_by_id = {
+        evidence["signal_id"]: evidence
+        for run in agent_runs
+        for evidence in run.evidence_bundle
+        if "signal_id" in evidence
+    }
+    return DiscoveryObjectiveWorkspaceResponse(
+        objective=response,
+        current_boundary=response.current_boundary,
+        plans=[await _plan_response(db, plan) for plan in plans],
+        assessments=list(
+            (
+                await db.scalars(
+                    select(DiscoveryAssessment)
+                    .where(DiscoveryAssessment.objective_id == objective_id)
+                    .order_by(DiscoveryAssessment.version.desc())
+                )
+            ).all()
+        ),
+        pending_approvals=list(
+            (
+                await db.scalars(
+                    select(OperatorApproval)
+                    .where(
+                        OperatorApproval.objective_id == objective_id,
+                        OperatorApproval.status == "pending",
+                    )
+                    .order_by(OperatorApproval.created_at.desc())
+                )
+            ).all()
+        ),
+        boundary_revisions=[
+            _revision_response(revision, boundary.version)
+            for revision, boundary in (
+                await db.execute(
+                    select(OperatorBoundaryRevision, ApprovedCollectionBoundary)
+                    .join(
+                        ApprovedCollectionBoundary,
+                        OperatorBoundaryRevision.boundary_id == ApprovedCollectionBoundary.id,
+                    )
+                    .where(OperatorBoundaryRevision.objective_id == objective_id)
+                    .order_by(OperatorBoundaryRevision.created_at.desc())
+                )
+            ).all()
+        ],
+        agent_runs=[AgentRunResponse.model_validate(run) for run in agent_runs],
+        evidence_bundle=list(evidence_by_id.values()),
+        need_hypotheses=list(
+            (
+                await db.scalars(
+                    select(NeedHypothesis)
+                    .where(NeedHypothesis.objective_id == objective_id)
+                    .order_by(NeedHypothesis.created_at.desc())
+                )
+            ).all()
+        ),
+        decision_record=(
+            await _decision_record_response(db, decision_record)
+            if decision_record is not None
+            else None
+        ),
+    )
+
+
+@router.post(
+    "/{objective_id}/assessments", response_model=DiscoveryAssessmentResponse, status_code=201
+)
+async def create_discovery_assessment(
+    objective_id: uuid.UUID,
+    body: DiscoveryAssessmentCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    if not body.evidence_ids and not body.assessment_ids:
+        raise HTTPException(
+            status_code=422, detail="Assessment requires evidence or upstream assessment citations"
+        )
+    objective = await db.scalar(
+        select(DiscoveryObjective).where(DiscoveryObjective.id == objective_id)
+    )
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    evidence_ids = set(body.evidence_ids)
+    if evidence_ids and len(
+        (
+            await db.scalars(select(ExternalSignal.id).where(ExternalSignal.id.in_(evidence_ids)))
+        ).all()
+    ) != len(evidence_ids):
+        raise HTTPException(
+            status_code=422, detail="Assessment cites an unknown evidence candidate"
+        )
+    upstream_assessment_ids = set(body.assessment_ids)
+    if upstream_assessment_ids and len(
+        (
+            await db.scalars(
+                select(DiscoveryAssessment.id).where(
+                    DiscoveryAssessment.id.in_(upstream_assessment_ids),
+                    DiscoveryAssessment.objective_id == objective_id,
+                )
+            )
+        ).all()
+    ) != len(upstream_assessment_ids):
+        raise HTTPException(
+            status_code=422,
+            detail="Assessment cites an upstream Assessment outside this Objective",
+        )
+    version = (
+        await db.scalar(
+            select(func.max(DiscoveryAssessment.version)).where(
+                DiscoveryAssessment.objective_id == objective_id
+            )
+        )
+        or 0
+    ) + 1
+    assessment = DiscoveryAssessment(
+        objective_id=objective_id, version=version, **body.model_dump(mode="json")
+    )
+    db.add(assessment)
+    await db.commit()
+    return assessment
+
+
+@router.post(
+    "/{objective_id}/need-hypotheses", response_model=NeedHypothesisResponse, status_code=201
+)
+async def create_need_hypothesis(
+    objective_id: uuid.UUID,
+    body: NeedHypothesisCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    assessments = list(
+        (
+            await db.scalars(
+                select(DiscoveryAssessment).where(
+                    DiscoveryAssessment.id.in_(body.support_assessment_ids),
+                    DiscoveryAssessment.objective_id == objective_id,
+                )
+            )
+        ).all()
+    )
+    if len(assessments) != len(body.support_assessment_ids) or not all(
+        a.kind == "support" and (a.evidence_ids or a.assessment_ids) for a in assessments
+    ):
+        raise HTTPException(
+            status_code=422, detail="Need Hypothesis requires cited support assessments"
+        )
+    hypothesis = NeedHypothesis(objective_id=objective_id, **body.model_dump(mode="json"))
+    db.add(hypothesis)
+    await db.commit()
+    return hypothesis
+
+
+@router.post("/{objective_id}/need-hypotheses/{hypothesis_id}/promote", status_code=201)
+async def promote_need_hypothesis(
+    objective_id: uuid.UUID,
+    hypothesis_id: uuid.UUID,
+    body: NeedHypothesisPromotion,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    hypothesis = await db.scalar(
+        select(NeedHypothesis).where(
+            NeedHypothesis.id == hypothesis_id, NeedHypothesis.objective_id == objective_id
+        )
+    )
+    if hypothesis is None:
+        raise HTTPException(status_code=404, detail="Need Hypothesis not found")
+    if hypothesis.status != "draft":
+        raise HTTPException(status_code=409, detail="Need Hypothesis is not promotable")
+    assessments = list(
+        (
+            await db.scalars(
+                select(DiscoveryAssessment).where(
+                    DiscoveryAssessment.id.in_(
+                        [uuid.UUID(value) for value in hypothesis.support_assessment_ids]
+                    )
+                )
+            )
+        ).all()
+    )
+    signal_ids = [
+        uuid.UUID(value) for assessment in assessments for value in assessment.evidence_ids
+    ]
+    signal = await db.scalar(
+        select(ExternalSignal).where(
+            ExternalSignal.id.in_(signal_ids), ExternalSignal.status == "accepted"
+        )
+    )
+    if signal is None:
+        raise HTTPException(
+            status_code=422, detail="Promotion requires an accepted evidence candidate"
+        )
+    need = await create_need_issue_from_accepted_signal(
+        NeedIssueFromAcceptedSignalCreate(
+            external_signal_id=signal.id,
+            title=hypothesis.title,
+            target_actor=hypothesis.target_actor,
+            context=hypothesis.context,
+            problem=hypothesis.problem,
+            desired_outcome=hypothesis.desired_outcome,
+            workaround=hypothesis.workaround,
+            unknowns=hypothesis.unknowns,
+            next_validation_action=hypothesis.next_validation_action,
+        ),
+        db,
+    )
+    hypothesis.status = "promoted"
+    hypothesis.promoted_need_issue_id = need.id
+    await db.commit()
+    return need
+
+
+@router.post(
+    "/{objective_id}/decision-records",
+    response_model=DiscoveryDecisionRecordResponse,
+    status_code=201,
+)
+async def close_with_decision_record(
+    objective_id: uuid.UUID,
+    body: DecisionRecordCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.get(DiscoveryObjective, objective_id)
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    if objective.status == "completed":
+        raise HTTPException(status_code=409, detail="Discovery Objective already closed")
+    cited_assessment_ids = set(body.support_assessment_ids + body.counter_assessment_ids)
+    if cited_assessment_ids:
+        citations = list(
+            (
+                await db.scalars(
+                    select(DiscoveryAssessment).where(
+                        DiscoveryAssessment.id.in_(cited_assessment_ids),
+                        DiscoveryAssessment.objective_id == objective_id,
+                    )
+                )
+            ).all()
+        )
+        if len(citations) != len(cited_assessment_ids):
+            raise HTTPException(
+                status_code=422,
+                detail="Decision Record cites an assessment outside this objective",
+            )
+    record = DiscoveryDecisionRecord(objective_id=objective_id, **body.model_dump(mode="json"))
+    objective.status = "completed"
+    db.add(record)
+    await db.commit()
+    return await _decision_record_response(db, record)
+
+
+@router.post(
+    "/{objective_id}/decision-records/{record_id}/outcomes",
+    response_model=OutcomeFeedbackResponse,
+    status_code=201,
+)
+async def append_outcome_feedback(
+    objective_id: uuid.UUID,
+    record_id: uuid.UUID,
+    body: OutcomeFeedbackCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    record = await db.scalar(
+        select(DiscoveryDecisionRecord).where(
+            DiscoveryDecisionRecord.id == record_id,
+            DiscoveryDecisionRecord.objective_id == objective_id,
+        )
+    )
+    if record is None:
+        raise HTTPException(status_code=404, detail="Discovery Decision Record not found")
+    outcome = OutcomeFeedback(decision_record_id=record_id, **body.model_dump())
+    db.add(outcome)
+    await db.commit()
+    return OutcomeFeedbackResponse.model_validate(outcome)
+
+
+@router.post("/{objective_id}/plans", response_model=AcquisitionPlanResponse, status_code=201)
+async def create_acquisition_plan(
+    objective_id: uuid.UUID,
+    body: AcquisitionPlanCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(_objective_with_boundaries(objective_id))
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    if objective.status != "active":
+        raise HTTPException(status_code=409, detail="Only an active objective can create a plan")
+
+    current_boundary = objective.boundaries[-1]
+    selected_source_ids = {str(source_id) for source_id in body.selected_source_ids}
+    if len(selected_source_ids) != len(body.selected_source_ids):
+        raise HTTPException(status_code=422, detail="Plan source IDs must not repeat")
+    if not selected_source_ids.issubset(set(current_boundary.approved_source_ids)):
+        raise HTTPException(
+            status_code=422,
+            detail="Plan sources are outside the approved boundary",
+        )
+    if (
+        body.request_budget > current_boundary.request_limit
+        or body.time_budget_minutes > current_boundary.time_budget_minutes
+        or body.cost_budget_cents > current_boundary.cost_budget_cents
+    ):
+        raise HTTPException(status_code=422, detail="Plan budget is outside the approved boundary")
+
+    latest_version = await db.scalar(
+        select(func.max(AcquisitionPlan.version)).where(
+            AcquisitionPlan.objective_id == objective_id
+        )
+    )
+    if body.predecessor_plan_id is not None:
+        predecessor = await db.scalar(_plan_with_missions(body.predecessor_plan_id))
+        if predecessor is None or predecessor.objective_id != objective_id:
+            raise HTTPException(
+                status_code=422,
+                detail="Plan predecessor does not belong to this objective",
+            )
+        if not body.revision_reason or body.revision_delta is None:
+            raise HTTPException(status_code=422, detail="Plan revision requires a reason and delta")
+    elif body.revision_reason or body.revision_delta is not None:
+        raise HTTPException(status_code=422, detail="Initial plan cannot include a revision record")
+
+    plan = AcquisitionPlan(
+        objective_id=objective_id,
+        boundary_id=current_boundary.id,
+        version=(latest_version or 0) + 1,
+        question=body.question,
+        selected_source_ids=[str(source_id) for source_id in body.selected_source_ids],
+        counterevidence_target=body.counterevidence_target,
+        request_budget=body.request_budget,
+        time_budget_minutes=body.time_budget_minutes,
+        cost_budget_cents=body.cost_budget_cents,
+    )
+    db.add(plan)
+    await db.flush()
+    if body.predecessor_plan_id is not None:
+        revision = PlanRevision(
+            plan_id=plan.id,
+            predecessor_plan_id=body.predecessor_plan_id,
+            reason=body.revision_reason,
+            delta=body.revision_delta,
+        )
+        db.add(revision)
+    await db.commit()
+    saved = await db.scalar(_plan_with_missions(plan.id))
+    return await _plan_response(db, saved)
+
+
+@router.post("/{objective_id}/approvals", response_model=OperatorApprovalResponse, status_code=201)
+async def request_operator_approval(
+    objective_id: uuid.UUID,
+    body: OperatorApprovalCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(_objective_with_boundaries(objective_id))
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    if objective.status != "active":
+        raise HTTPException(status_code=409, detail="Only an active objective can request approval")
+    if not body.requested_boundary_patch.model_dump(exclude_none=True):
+        raise HTTPException(status_code=422, detail="Approval request requires a boundary delta")
+
+    approval = OperatorApproval(
+        objective_id=objective_id,
+        request_type=body.request_type,
+        reason=body.reason,
+        requested_boundary_patch=body.requested_boundary_patch.model_dump(
+            exclude_none=True, mode="json"
+        ),
+    )
+    objective.status = "pending_approval"
+    db.add(approval)
+    await db.commit()
+    return approval
+
+
+@router.post(
+    "/{objective_id}/approvals/{approval_id}/approve",
+    response_model=OperatorApprovalResponse,
+)
+async def approve_operator_request(
+    objective_id: uuid.UUID,
+    approval_id: uuid.UUID,
+    body: OperatorApprovalDecision,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(_objective_with_boundaries(objective_id))
+    approval = await db.scalar(
+        select(OperatorApproval).where(
+            OperatorApproval.id == approval_id,
+            OperatorApproval.objective_id == objective_id,
+        )
+    )
+    if objective is None or approval is None:
+        raise HTTPException(status_code=404, detail="Approval request not found")
+    if objective.status != "pending_approval" or approval.status != "pending":
+        raise HTTPException(status_code=409, detail="Approval request is not awaiting a decision")
+
+    boundary, normalized_patch = await _apply_boundary_patch(
+        db,
+        objective,
+        objective.boundaries[-1],
+        BoundaryPatch.model_validate(approval.requested_boundary_patch),
+    )
+    revision = OperatorBoundaryRevision(
+        objective_id=objective_id,
+        boundary_id=boundary.id,
+        approval_id=approval.id,
+        operator=body.operator,
+        reason=body.reason,
+        boundary_patch=normalized_patch,
+    )
+    approval.status = "approved"
+    approval.operator = body.operator
+    approval.decision_reason = body.reason
+    approval.decided_at = datetime.now(UTC)
+    objective.status = "active"
+    db.add(revision)
+    await db.commit()
+    return approval
+
+
+@router.post(
+    "/{objective_id}/approvals/{approval_id}/reject",
+    response_model=OperatorApprovalResponse,
+)
+async def reject_operator_request(
+    objective_id: uuid.UUID,
+    approval_id: uuid.UUID,
+    body: OperatorApprovalDecision,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(
+        select(DiscoveryObjective).where(DiscoveryObjective.id == objective_id)
+    )
+    approval = await db.scalar(
+        select(OperatorApproval).where(
+            OperatorApproval.id == approval_id,
+            OperatorApproval.objective_id == objective_id,
+        )
+    )
+    if objective is None or approval is None:
+        raise HTTPException(status_code=404, detail="Approval request not found")
+    if objective.status != "pending_approval" or approval.status != "pending":
+        raise HTTPException(status_code=409, detail="Approval request is not awaiting a decision")
+
+    approval.status = "rejected"
+    approval.operator = body.operator
+    approval.decision_reason = body.reason
+    approval.decided_at = datetime.now(UTC)
+    objective.status = "active"
+    await db.commit()
+    return approval
+
+
+@router.post("/{objective_id}/block", response_model=DiscoveryObjectiveResponse)
+async def block_discovery_objective(
+    objective_id: uuid.UUID,
+    body: ObjectiveBlockRequest,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(_objective_with_boundaries(objective_id))
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    if objective.status != "active":
+        raise HTTPException(status_code=409, detail="Only an active objective can become blocked")
+    objective.status = "blocked"
+    objective.block_reason = body.reason
+    await db.commit()
+    blocked = await db.scalar(_objective_with_boundaries(objective_id))
+    return _response_for(blocked)
+
+
+@router.post(
+    "/{objective_id}/boundary-revisions",
+    response_model=OperatorBoundaryRevisionResponse,
+    status_code=201,
+)
+async def reactivate_with_boundary_revision(
+    objective_id: uuid.UUID,
+    body: OperatorBoundaryRevisionCreate,
+    db: Annotated[AsyncSession, Depends(get_db)],
+):
+    objective = await db.scalar(_objective_with_boundaries(objective_id))
+    if objective is None:
+        raise HTTPException(status_code=404, detail="Discovery Objective not found")
+    if objective.status != "blocked":
+        raise HTTPException(
+            status_code=409,
+            detail="Boundary revision can reactivate only a blocked objective",
+        )
+
+    boundary, normalized_patch = await _apply_boundary_patch(
+        db, objective, objective.boundaries[-1], body.boundary_patch
+    )
+    revision = OperatorBoundaryRevision(
+        objective_id=objective_id,
+        boundary_id=boundary.id,
+        operator=body.operator,
+        reason=body.reason,
+        boundary_patch=normalized_patch,
+    )
+    objective.status = "active"
+    objective.block_reason = None
+    db.add(revision)
+    await db.commit()
+    return _revision_response(revision, boundary.version)
diff --git a/apps/api/routers/external_signals.py b/apps/api/routers/external_signals.py
index 181382e..c45215b 100644
--- a/apps/api/routers/external_signals.py
+++ b/apps/api/routers/external_signals.py
@@ -16,6 +16,7 @@
     SignalTriageCreate,
 )
 from packages.storage.models.external_signal import ExternalSignal, SignalTriageEvent
+from packages.storage.models.source import Source
 
 router = APIRouter()
 inbox_router = APIRouter()
@@ -41,6 +42,8 @@ async def create_external_signal(
     body: ExternalSignalCreate,
     db: Annotated[AsyncSession, Depends(get_db)],
 ):
+    if body.source_id is not None and await db.get(Source, body.source_id) is None:
+        raise HTTPException(status_code=422, detail="External Signal source does not exist")
     signal = ExternalSignal(**body.model_dump())
     db.add(signal)
     await db.commit()
diff --git a/apps/api/schemas/acquisition_mission.py b/apps/api/schemas/acquisition_mission.py
index 532bc58..cf252b3 100644
--- a/apps/api/schemas/acquisition_mission.py
+++ b/apps/api/schemas/acquisition_mission.py
@@ -27,11 +27,13 @@ class AcquisitionMissionFields(BaseModel):
 
 class AcquisitionMissionCreate(AcquisitionMissionFields):
     source_config_version_id: uuid.UUID
+    acquisition_plan_id: uuid.UUID | None = None
 
 
 class AcquisitionMissionResponse(AcquisitionMissionFields):
     id: uuid.UUID
     source_config_version_id: uuid.UUID | None
+    acquisition_plan_id: uuid.UUID | None
     source_config_version: SourceConfigVersionResponse | None
     status: str
     created_at: datetime
diff --git a/apps/api/schemas/agent_run.py b/apps/api/schemas/agent_run.py
index 833abda..3fc5017 100644
--- a/apps/api/schemas/agent_run.py
+++ b/apps/api/schemas/agent_run.py
@@ -2,6 +2,7 @@
 
 import uuid
 from datetime import datetime
+from typing import Literal
 
 from pydantic import BaseModel, Field
 
@@ -15,11 +16,19 @@ class AgentRunCreate(BaseModel):
     max_tool_calls: int = Field(gt=0, le=20)
     max_tokens: int = Field(gt=0, le=20_000)
     max_cost_cents: int = Field(ge=0, le=10_000)
+    max_time_minutes: int = Field(default=1, gt=0, le=240)
+    acquisition_plan_id: uuid.UUID | None = None
+    proposal_type: Literal["assessment", "plan_revision"] = "assessment"
 
 
 class AgentRunResponse(BaseModel):
     id: uuid.UUID
     idempotency_key: str
+    objective_id: uuid.UUID | None
+    boundary_id: uuid.UUID | None
+    boundary_version: int | None
+    acquisition_plan_id: uuid.UUID | None
+    input_context: dict | None
     task_instruction: str
     evidence_bundle: list[dict]
     evidence_bundle_hash: str
diff --git a/apps/api/schemas/discovery_objective.py b/apps/api/schemas/discovery_objective.py
new file mode 100644
index 0000000..7e9c205
--- /dev/null
+++ b/apps/api/schemas/discovery_objective.py
@@ -0,0 +1,251 @@
+"""Public contracts for bounded Discovery Objectives."""
+
+import uuid
+from datetime import datetime
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, Field, StringConstraints
+
+from apps.api.schemas.acquisition_mission_run import AcquisitionMissionRunResponse
+from apps.api.schemas.agent_run import AgentRunResponse
+
+NonEmptyText = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1)]
+
+
+class InitialCollectionBoundary(BaseModel):
+    approved_source_ids: list[uuid.UUID] = Field(min_length=1)
+    tool_allowlist: list[NonEmptyText] = Field(min_length=1)
+    request_limit: int = Field(gt=0)
+    time_budget_minutes: int = Field(gt=0)
+    cost_budget_cents: int = Field(ge=0)
+    credential_scope: list[NonEmptyText] = Field(default_factory=list)
+    evidence_conditions: list[NonEmptyText] = Field(default_factory=list)
+
+
+class BoundaryPatch(BaseModel):
+    approved_source_ids: list[uuid.UUID] | None = Field(default=None, min_length=1)
+    tool_allowlist: list[NonEmptyText] | None = Field(default=None, min_length=1)
+    request_limit: int | None = Field(default=None, gt=0)
+    time_budget_minutes: int | None = Field(default=None, gt=0)
+    cost_budget_cents: int | None = Field(default=None, ge=0)
+    credential_scope: list[NonEmptyText] | None = None
+    evidence_conditions: list[NonEmptyText] | None = None
+
+
+class DiscoveryObjectiveCreate(BaseModel):
+    title: NonEmptyText = Field(max_length=200)
+    question: NonEmptyText
+    resource_stop_conditions: list[NonEmptyText] = Field(min_length=1)
+    evidence_stop_conditions: list[NonEmptyText] = Field(min_length=1)
+    decision_stop_conditions: list[NonEmptyText] = Field(min_length=1)
+    initial_boundary: InitialCollectionBoundary
+
+
+class ApprovedCollectionBoundaryResponse(BaseModel):
+    id: uuid.UUID
+    objective_id: uuid.UUID
+    version: int
+    approved_source_ids: list[uuid.UUID]
+    tool_allowlist: list[str]
+    request_limit: int
+    time_budget_minutes: int
+    cost_budget_cents: int
+    credential_scope: list[str]
+    evidence_conditions: list[str]
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class DiscoveryObjectiveResponse(BaseModel):
+    id: uuid.UUID
+    title: str
+    question: str
+    resource_stop_conditions: list[str]
+    evidence_stop_conditions: list[str]
+    decision_stop_conditions: list[str]
+    status: str
+    created_at: datetime
+    updated_at: datetime
+    current_boundary: ApprovedCollectionBoundaryResponse
+
+    model_config = {"from_attributes": True}
+
+
+class DiscoveryObjectiveWorkspaceResponse(BaseModel):
+    objective: DiscoveryObjectiveResponse
+    current_boundary: ApprovedCollectionBoundaryResponse
+    plans: list["AcquisitionPlanResponse"] = Field(default_factory=list)
+    assessments: list["DiscoveryAssessmentResponse"] = Field(default_factory=list)
+    pending_approvals: list["OperatorApprovalResponse"] = Field(default_factory=list)
+    boundary_revisions: list["OperatorBoundaryRevisionResponse"] = Field(default_factory=list)
+    agent_runs: list[AgentRunResponse] = Field(default_factory=list)
+    evidence_bundle: list[dict] = Field(default_factory=list)
+    need_hypotheses: list["NeedHypothesisResponse"] = Field(default_factory=list)
+    decision_record: "DiscoveryDecisionRecordResponse | None" = None
+
+
+class OperatorApprovalCreate(BaseModel):
+    request_type: NonEmptyText = Field(max_length=64)
+    reason: NonEmptyText
+    requested_boundary_patch: BoundaryPatch
+
+
+class OperatorApprovalDecision(BaseModel):
+    operator: NonEmptyText = Field(max_length=120)
+    reason: NonEmptyText
+
+
+class OperatorApprovalResponse(BaseModel):
+    id: uuid.UUID
+    objective_id: uuid.UUID
+    request_type: str
+    reason: str
+    requested_boundary_patch: dict
+    status: str
+    operator: str | None
+    decision_reason: str | None
+    decided_at: datetime | None
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class OperatorBoundaryRevisionCreate(BaseModel):
+    operator: NonEmptyText = Field(max_length=120)
+    reason: NonEmptyText
+    boundary_patch: BoundaryPatch
+
+
+class OperatorBoundaryRevisionResponse(BaseModel):
+    id: uuid.UUID
+    objective_id: uuid.UUID
+    boundary_id: uuid.UUID
+    boundary_version: int
+    approval_id: uuid.UUID | None
+    operator: str
+    reason: str
+    boundary_patch: dict
+    created_at: datetime
+
+
+class ObjectiveBlockRequest(BaseModel):
+    reason: NonEmptyText
+
+
+class AcquisitionPlanCreate(BaseModel):
+    question: NonEmptyText
+    selected_source_ids: list[uuid.UUID] = Field(min_length=1)
+    counterevidence_target: NonEmptyText
+    request_budget: int = Field(gt=0)
+    time_budget_minutes: int = Field(gt=0)
+    cost_budget_cents: int = Field(ge=0)
+    predecessor_plan_id: uuid.UUID | None = None
+    revision_reason: NonEmptyText | None = None
+    revision_delta: dict | None = None
+
+
+class PlanRevisionResponse(BaseModel):
+    id: uuid.UUID
+    predecessor_plan_id: uuid.UUID
+    reason: str
+    delta: dict
+    created_at: datetime
+
+
+class AcquisitionPlanResponse(BaseModel):
+    id: uuid.UUID
+    objective_id: uuid.UUID
+    boundary_id: uuid.UUID
+    boundary_version: int
+    version: int
+    question: str
+    selected_source_ids: list[uuid.UUID]
+    counterevidence_target: str
+    request_budget: int
+    time_budget_minutes: int
+    cost_budget_cents: int
+    created_at: datetime
+    predecessor_plan_id: uuid.UUID | None
+    revision: PlanRevisionResponse | None
+    missions: list[uuid.UUID]
+    mission_runs: dict[uuid.UUID, list[AcquisitionMissionRunResponse]] = Field(default_factory=dict)
+
+
+class DiscoveryAssessmentCreate(BaseModel):
+    kind: str = Field(
+        pattern="^(support|counterevidence|unknown|coverage_gap|blocked|recommendation)$"
+    )
+    statement: NonEmptyText
+    evidence_ids: list[uuid.UUID] = Field(default_factory=list)
+    assessment_ids: list[uuid.UUID] = Field(default_factory=list)
+    unknowns: list[NonEmptyText] = Field(default_factory=list)
+    coverage_gaps: list[NonEmptyText] = Field(default_factory=list)
+    recommendation: NonEmptyText | None = None
+    evidence_strength: Literal["unknown", "weak", "moderate", "strong"] = "unknown"
+
+
+class DiscoveryAssessmentResponse(DiscoveryAssessmentCreate):
+    id: uuid.UUID
+    objective_id: uuid.UUID
+    version: int
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class NeedHypothesisCreate(BaseModel):
+    title: NonEmptyText = Field(max_length=255)
+    target_actor: NonEmptyText
+    context: NonEmptyText
+    problem: NonEmptyText
+    desired_outcome: NonEmptyText
+    workaround: NonEmptyText | None = None
+    unknowns: list[NonEmptyText] = Field(default_factory=list)
+    next_validation_action: NonEmptyText
+    support_assessment_ids: list[uuid.UUID] = Field(min_length=1)
+
+
+class NeedHypothesisResponse(NeedHypothesisCreate):
+    id: uuid.UUID
+    objective_id: uuid.UUID
+    status: str
+    promoted_need_issue_id: uuid.UUID | None
+    created_at: datetime
+    model_config = {"from_attributes": True}
+
+
+class NeedHypothesisPromotion(BaseModel):
+    operator: NonEmptyText
+
+
+class DecisionRecordCreate(BaseModel):
+    decision: Literal["promoted", "rewritten", "abandoned", "blocked"]
+    reason: NonEmptyText
+    support_assessment_ids: list[uuid.UUID] = Field(default_factory=list)
+    counter_assessment_ids: list[uuid.UUID] = Field(default_factory=list)
+    unknowns: list[NonEmptyText] = Field(default_factory=list)
+    resource_usage: dict = Field(default_factory=dict)
+
+
+class OutcomeFeedbackCreate(BaseModel):
+    kind: NonEmptyText
+    reference: NonEmptyText
+    summary: NonEmptyText
+
+
+class OutcomeFeedbackResponse(OutcomeFeedbackCreate):
+    id: uuid.UUID
+    decision_record_id: uuid.UUID
+    created_at: datetime
+
+    model_config = {"from_attributes": True}
+
+
+class DiscoveryDecisionRecordResponse(DecisionRecordCreate):
+    id: uuid.UUID
+    objective_id: uuid.UUID
+    created_at: datetime
+    outcomes: list[OutcomeFeedbackResponse] = Field(default_factory=list)
+
+    model_config = {"from_attributes": True}
diff --git a/apps/api/schemas/external_signal.py b/apps/api/schemas/external_signal.py
index b350569..fc3190d 100644
--- a/apps/api/schemas/external_signal.py
+++ b/apps/api/schemas/external_signal.py
@@ -8,6 +8,7 @@
 
 
 class ExternalSignalCreate(BaseModel):
+    source_id: uuid.UUID | None = None
     source_label: str = Field(min_length=1)
     source_uri: str | None = None
     original_material: str = Field(min_length=1)
@@ -33,6 +34,7 @@ class SignalTriageEventResponse(BaseModel):
 class ExternalSignalResponse(BaseModel):
     id: uuid.UUID
     mission_run_id: uuid.UUID | None
+    source_id: uuid.UUID | None
     mission_run_ids: list[uuid.UUID] = Field(default_factory=list)
     lineage_key: str | None
     raw_artifact_key: str | None
diff --git a/apps/web/main.py b/apps/web/main.py
index 8a11410..3ebc101 100644
--- a/apps/web/main.py
+++ b/apps/web/main.py
@@ -10,6 +10,7 @@
     jobs,
     missions,
     needs,
+    objectives,
     observations,
     ontology,
     portfolio,
@@ -22,6 +23,7 @@
 web_app.include_router(experiments.router)
 web_app.include_router(web_sources.router)
 web_app.include_router(missions.router)
+web_app.include_router(objectives.router)
 web_app.include_router(observations.router)
 web_app.include_router(agents.router)
 web_app.include_router(ontology.router)
diff --git a/apps/web/routers/objectives.py b/apps/web/routers/objectives.py
new file mode 100644
index 0000000..9d4d1a5
--- /dev/null
+++ b/apps/web/routers/objectives.py
@@ -0,0 +1,19 @@
+"""Web entry point for one Discovery Objective workspace."""
+
+import uuid
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+
+from ..templating import templates
+
+router = APIRouter(prefix="/objectives", tags=["Web Discovery Objectives"])
+
+
+@router.get("/{objective_id}", response_class=HTMLResponse)
+async def discovery_objective_workspace(objective_id: uuid.UUID, request: Request):
+    return templates.TemplateResponse(
+        request,
+        "objectives/workspace.html",
+        {"title": "Discovery Objective", "objective_id": objective_id},
+    )
diff --git a/apps/web/static/style.css b/apps/web/static/style.css
index 1ef0e0c..04abfe7 100644
--- a/apps/web/static/style.css
+++ b/apps/web/static/style.css
@@ -1,49 +1,23 @@
-/* SourceOS — minimal custom styles on top of Pico.css */
-
-.status-active { color: var(--pico-color-green-400); font-weight: bold; }
-.status-paused { color: var(--pico-color-amber-400); }
-.status-error { color: var(--pico-color-red-400); font-weight: bold; }
-.status-discovered { color: var(--pico-color-blue-400); }
-.status-fetched { color: var(--pico-color-green-400); }
-.status-failed { color: var(--pico-color-red-400); }
-.status-success { color: var(--pico-color-green-400); }
-.status-queued { color: var(--pico-color-grey-400); }
-.status-running { color: var(--pico-color-amber-400); }
-
-.badge {
-    display: inline-block;
-    padding: 0.1rem 0.5rem;
-    background: var(--pico-color-grey-100);
-    border-radius: 4px;
-    font-size: 0.8rem;
-    font-weight: 500;
-}
-
-.error-code {
-    font-family: monospace;
-    font-size: 0.85rem;
-    background: var(--pico-color-red-50);
-    padding: 0.1rem 0.4rem;
-    border-radius: 3px;
-}
-
-.markdown-body {
-    max-width: 800px;
-    line-height: 1.7;
-}
-.markdown-body img { max-width: 100%; }
-.markdown-body pre { overflow-x: auto; }
-
-.workbench-heading, .section-heading { display: flex; align-items: start; justify-content: space-between; gap: 1rem; }
-.workbench-heading > div, .section-heading > div { max-width: 48rem; }
-.workbench-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(20rem, 1fr)); gap: 1rem; }
-.eyebrow { margin-bottom: .25rem; color: var(--pico-primary); font-size: .75rem; font-weight: 700; letter-spacing: .08em; text-transform: uppercase; }
-.config-status { margin: 1rem 0 0; font-size: .9rem; }
-.execution-warning { align-self: end; padding: .85rem 1rem; border-left: 3px solid var(--pico-color-amber-400); background: var(--pico-card-background-color); }
-.message-error { border-left: 4px solid var(--pico-color-red-400); }
-.message-success { border-left: 4px solid var(--pico-color-green-400); }
-.run-metrics { display: flex; flex-wrap: wrap; gap: .75rem 1.25rem; margin: 1rem 0; }
-.run-metrics span { font-size: .9rem; }
-.failure-detail { color: var(--pico-color-red-400); }
-.evidence-list { display: grid; gap: .75rem; }
-@media (max-width: 600px) { .workbench-heading, .section-heading { flex-direction: column; } }
+/* SourceOS control room — operator-facing collection workspace */
+:root { --ink: #20251f; --ink-2: #313830; --canvas: #d9d7cf; --paper: #f5f4ef; --panel: #fffefa; --line: #d8d6ce; --muted: #777b73; --green: #215442; --green-soft: #dceae1; --amber: #c49439; --red: #a94432; --red-soft: #f6e5dd; --shadow: 0 12px 24px rgba(30, 37, 31, .06); --pico-font-family: "Avenir Next", "PingFang SC", "Noto Sans SC", sans-serif; --pico-border-radius: 14px; --pico-primary: var(--green); --pico-primary-background: var(--green); --pico-primary-border: var(--green); --pico-form-element-border-color: var(--line); --pico-form-element-background-color: #fffefa; --pico-card-background-color: var(--panel); }
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--canvas); color: var(--ink); font-size: 14px; }
+.app-shell { display: grid; grid-template-columns: 222px minmax(0, 1fr); grid-template-rows: 58px minmax(0, 1fr); height: min(920px, 94vh); max-width: 1500px; margin: 24px auto; overflow: hidden; border: 1px solid #c7c4bb; border-radius: 16px; background: var(--paper); box-shadow: 0 28px 80px rgba(32,35,31,.22); }
+.app-sidebar { grid-column: 1; grid-row: 1 / -1; display: flex; flex-direction: column; padding: 0 11px 18px; background: #242722; color: #edf0ea; }
+.brand-lockup { display: flex; align-items: center; gap: 11px; min-height: 58px; margin: 0 -11px 15px; padding: 0 19px; border-bottom: 1px solid #3b3e38; color: #f8f8f4; text-decoration: none; font-size: 14px; }
+.brand-lockup small { margin-left: auto; color: #aeb3aa; font-size: 10px; font-weight: 500; }.brand-mark { display: grid; width: 27px; height: 27px; place-items: center; border: 1px solid #899187; border-radius: 7px; font-size: 11px; font-weight: 800; letter-spacing: -1px; }
+.primary-nav, .secondary-nav { display: grid; gap: 4px; }
+.app-sidebar nav a { display: flex; align-items: center; gap: 10px; min-height: 37px; padding: 0 10px; border-radius: 7px; color: #c6cbc2; font-size: 13px; font-weight: 600; text-decoration: none; }.app-sidebar nav a span { color: #9da49b; font-size: 16px; line-height: 1; }.app-sidebar nav a b { min-width: 20px; margin-left: auto; padding: 1px 6px; border-radius: 9px; background: #3b4039; color: #dfe3dc; font-size: 10px; text-align: center; }
+.app-sidebar nav a.active, .app-sidebar nav a:hover { background: #f2f5ef; color: #213128; }.app-sidebar nav a.active span { color: var(--green); }.app-sidebar nav a.active b { background: #d5e7dc; color: var(--green); }
+.nav-label { margin: 13px 10px 7px; color: #83897f; font-size: 10px; letter-spacing: .12em; }.weekly-budget { margin: auto 9px 0; padding-top: 13px; border-top: 1px solid #3a4039; color: #eef0ec; }.weekly-budget strong { font-size: 11px; }.weekly-budget small { color: #9da49b; font-size: 10px; }.budget-track { height: 4px; margin: 8px 0 5px; overflow: hidden; border-radius: 999px; background: #4b544a; }.budget-track i { display: block; width: 41%; height: 100%; border-radius: inherit; background: #8fab97; }
+.app-frame { grid-column: 2; grid-row: 1 / -1; min-width: 0; display: grid; grid-template-rows: 58px minmax(0, 1fr); }.topbar { display: flex; align-items: center; justify-content: space-between; min-height: 58px; padding: 0 20px; border-bottom: 1px solid var(--line); background: #fbfaf6; }.topbar p { margin: 0; color: var(--muted); font-size: 13px; }.topbar strong { color: var(--ink); }.topbar-actions { display: flex; align-items: center; gap: 14px; color: var(--muted); }.command-search { display: flex; align-items: center; width: 260px; margin: 0; padding: 0 11px; border: 1px solid var(--line); border-radius: 8px; background: #fff; }.command-search span { margin-right: 10px; color: #92978f; white-space: nowrap; }.command-search input { height: 35px; margin: 0; padding: 0; border: 0; box-shadow: none; background: transparent; font-size: 13px; }.command-search input:focus { box-shadow: none; }.operator-avatar { display: grid; width: 29px; height: 29px; place-items: center; border-radius: 50%; background: var(--green); color: #fff; font-size: 11px; }
+.app-content { padding: 18px 20px 20px; overflow: auto; }.collection-heading { display: flex; align-items: flex-end; justify-content: space-between; gap: 20px; margin-bottom: 15px; }.collection-heading h1 { margin: 0 0 3px; font-family: Georgia, "Songti SC", serif; font-size: 24px; letter-spacing: -.02em; }.collection-heading p:not(.eyebrow) { margin: 0; color: var(--muted); font-size: 13px; }.eyebrow { display: none; }.head-actions { display:flex; gap:8px; }.collection-heading a[role=button], .head-actions button { min-height: 35px; margin: 0; padding: 8px 12px; }
+article, .collection-panel > section { margin: 0; border: 1px solid var(--line); border-radius: 16px; background: var(--panel); box-shadow: var(--shadow); }article > header { display: flex; justify-content: space-between; align-items: center; min-height: 66px; padding: 0 18px; border-bottom: 1px solid var(--line); font-size: 17px; }article > header small { color: var(--muted); font-size: 13px; font-weight: 500; }.cold-water-notice { display: grid; grid-template-columns: auto 1fr auto; gap: 18px; align-items: center; margin-bottom: 20px; padding: 15px 20px; border-color: #e3b9aa; background: var(--red-soft); box-shadow: none; color: #4c423e; }.cold-water-notice strong { color: var(--red); }.cold-water-notice a { color: var(--red); font-weight: 750; text-decoration: none; white-space: nowrap; }
+#collection-layout { display: grid; grid-template-columns: 280px minmax(430px, 1fr) 320px; gap: 18px; align-items: start; }.collection-panel { display: grid; gap: 18px; min-width: 0; }.collection-panel article { padding-bottom: 18px; }.collection-panel article > :not(header) { margin-right: 18px; margin-left: 18px; }.collection-panel h2 { margin-top: 17px; font-size: 19px; }.collection-panel p { line-height: 1.6; }.source-library-link { width: calc(100% - 36px); margin-top: 20px !important; }
+label { color: #62675f; font-size: 13px; font-weight: 700; } input, textarea, select { margin-top: 7px; margin-bottom: 14px; border-color: var(--line); border-radius: 10px; box-shadow: none; font-size: 15px; } textarea { line-height: 1.48; } button, [role=button] { min-height: 42px; border-radius: 10px; font-size: 14px; font-weight: 750; } button:active, [role=button]:active { transform: translateY(1px); }
+.app-content button:not(.secondary):not(.outline), .app-content [role=button]:not(.secondary):not(.outline) { background: var(--green); border-color: var(--green); color: #fff; } .app-content button.secondary, .app-content [role=button].secondary { background: #e9ece7; border-color: var(--line); color: #334038; } .app-content button.outline, .app-content [role=button].outline, .app-content button.secondary.outline, .app-content [role=button].secondary.outline { background: transparent; border-color: #bfc5ba; color: #334038; }
+#mission-editor .grid { grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 14px; }#mission-editor .grid:has(#request-limit) { grid-template-columns: repeat(3, minmax(0, 1fr)); }#mission-editor .grid:has(#time-budget) { grid-template-columns: repeat(3, minmax(0, 1fr)); }.config-status { padding: 11px 13px; border-radius: 9px; background: #eff2ed; color: #526256; font-size: 13px; }.execution-warning { padding: 13px; border-left: 3px solid var(--amber); border-radius: 8px; background: #f7f1df; }.triage-actions { display: flex; flex-wrap: wrap; gap: 8px; }.run-metrics { display: grid; grid-template-columns: repeat(2, 1fr); gap: 8px; }.run-metrics span { padding: 9px; border-radius: 8px; background: #f1f0eb; color: var(--muted); font-size: 12px; }.run-metrics strong { display: block; color: var(--ink); font-size: 15px; }.failure-detail { color: var(--red); }.message-error { margin-bottom: 14px; padding: 10px 14px; border-left: 4px solid var(--red); }.message-success { margin-bottom: 14px; padding: 10px 14px; border-left: 4px solid var(--green); }.evidence-list { display: grid; gap: 8px; }.evidence-list article { box-shadow: none; }.evidence-list article > header { min-height: 46px; font-size: 14px; }.rail-history, .rail-inbox { border: 0 !important; background: transparent !important; box-shadow: none !important; }.rail-history > .section-heading, .rail-inbox > .section-heading { padding: 0 0 10px; }.rail-history > p, .rail-inbox > p { color: var(--muted); font-size: 12px; }.rail-history .evidence-list article, .rail-inbox .evidence-list article { padding-bottom: 12px; }.badge { display: inline-block; padding: 3px 7px; border-radius: 999px; background: var(--green-soft); color: var(--green); font-size: 11px; font-weight: 800; }.error-code { font-family: monospace; background: var(--red-soft); padding: 2px 5px; border-radius: 3px; }.markdown-body { max-width: 800px; line-height: 1.7; }.markdown-body img { max-width: 100%; }.markdown-body pre { overflow-x: auto; }
+.collection-tabs { display:flex; gap:2px; margin-bottom:15px; border-bottom:1px solid var(--line); }.collection-tabs a, .collection-tabs button { min-height:0; padding:9px 12px 10px; border:0; border-bottom:2px solid transparent; border-radius:0; background:transparent !important; color:var(--muted) !important; font-size:13px; font-weight:500; text-decoration:none; }.collection-tabs .active { color:var(--green) !important; border-bottom-color:var(--green); font-weight:700; }.collection-tabs small { margin-left:4px; padding:1px 5px; border-radius:10px; background:#e3e1da; font-size:10px; }.cold-water-notice { margin-bottom:15px; padding:12px 14px; border-left:4px solid var(--red); border-radius:9px; }.cold-water-notice strong { font-size:11px; letter-spacing:.08em; }.cold-water-notice span { font-size:13px; }.cold-water-notice a { font-size:11px; }
+#collection-layout { grid-template-columns:minmax(250px,.72fr) minmax(460px,1.5fr) minmax(255px,.78fr); gap:12px; }.collection-panel { gap:12px; }.collection-panel article { padding-bottom:12px; }.collection-panel article > :not(header) { margin-right:12px; margin-left:12px; }.collection-panel h2 { margin-top:12px; font-size:15px; }.collection-panel p { line-height:1.45; }.source-library-link { width:calc(100% - 24px); margin-top:8px !important; }
+@media (max-width: 1280px) { .app-shell { margin: 0; max-width: none; border-radius: 0; }.app-sidebar { width: 248px; }.app-shell { grid-template-columns: 248px minmax(0, 1fr); } #collection-layout { grid-template-columns: 230px minmax(360px, 1fr); }.operation-rail { grid-column: 1 / -1; grid-template-columns: repeat(3, 1fr); display: grid; }.command-search { width: 260px; } }
+@media (max-width: 820px) { .app-shell { display: block; }.app-sidebar { display: none; }.topbar { padding: 0 16px; }.topbar-actions small, .command-search { display: none; }.app-content { padding: 20px 16px; }.collection-heading { align-items: flex-start; flex-direction: column; }.cold-water-notice { grid-template-columns: 1fr; gap: 7px; }.cold-water-notice a { white-space: normal; } #collection-layout, .operation-rail { display: grid; grid-template-columns: 1fr; }.collection-panel { gap: 14px; } #mission-editor .grid, #mission-editor .grid:has(#request-limit), #mission-editor .grid:has(#time-budget) { grid-template-columns: 1fr; } }
diff --git a/apps/web/templates/base.html b/apps/web/templates/base.html
index 7218493..580b48f 100644
--- a/apps/web/templates/base.html
+++ b/apps/web/templates/base.html
@@ -5,39 +5,36 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>{% block title %}SourceOS{% endblock %} — 现实需求发现工作台</title>
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico@2/css/pico.min.css">
-    <link rel="stylesheet" href="/static/style.css">
+    <link rel="stylesheet" href="/static/style.css?v=control-room-canonical-v2">
 </head>
 <body>
-    <header class="container">
-        <nav>
-            <ul>
-                <li><strong><a href="/" style="text-decoration:none">SourceOS</a></strong></li>
-            </ul>
-            <ul>
-                <li><a href="/">Dashboard</a></li>
-                <li><a href="/sources">Sources</a></li>
-                <li><a href="/portfolio">Portfolio</a></li>
-                <li><a href="/missions">Missions</a></li>
-                <li><a href="/observations">Observe</a></li>
-                <li><a href="/agents">Agents</a></li>
-                <li><a href="/ontology">Ontology</a></li>
-                <li><a href="/needs">Needs</a></li>
-                <li><a href="/experiments">Experiments</a></li>
-                <li><a href="/product-theses">Theses</a></li>
-                <li><a href="/features">Features</a></li>
-                <li><a href="/items">Items</a></li>
-                <li><a href="/jobs">Jobs</a></li>
-                <li><a href="/api/docs" target="_blank">API</a></li>
-            </ul>
-        </nav>
-    </header>
-
-    <main class="container">
-        {% block content %}{% endblock %}
-    </main>
-
-    <footer class="container">
-        <small>SourceOS v0.1.0 — 证据驱动的现实需求发现与产品验证工作台</small>
-    </footer>
+    <div class="app-shell">
+        <aside class="app-sidebar">
+            <a class="brand-lockup" href="/"><span class="brand-mark">SO</span><strong>SourceOS</strong><small>私人经营系统</small></a>
+            <nav class="primary-nav" aria-label="主要导航">
+                <a href="/"><span>□</span>今天</a>
+                <a class="active" href="/missions"><span>□</span>现实采集 <b>3</b></a>
+                <a href="/needs"><span>□</span>需求挑战 <b>7</b></a>
+                <a href="/experiments"><span>□</span>市场验证</a>
+                <a href="/product-theses"><span>□</span>产品下注</a>
+                <a href="/features"><span>□</span>交付结果</a>
+            </nav>
+            <p class="nav-label">知识与校准</p>
+            <nav class="secondary-nav" aria-label="辅助导航">
+                <a href="/sources"><span>□</span>采集源</a>
+                <a href="/portfolio"><span>□</span>信源组合</a>
+                <a href="/ontology"><span>□</span>本体关联</a>
+                <a href="/agents"><span>□</span>智能体</a>
+            </nav>
+            <div class="weekly-budget"><strong>本周现实接触预算</strong><div class="budget-track"><i></i></div><small>已使用 2.9 / 7 小时</small></div>
+        </aside>
+        <section class="app-frame">
+            <header class="topbar">
+                <p>{% block breadcrumb %}现实采集 / <strong>采集控制台</strong>{% endblock %}</p>
+                <div class="topbar-actions"><label class="command-search"><span>⌘ K</span><input aria-label="搜索" placeholder="搜索来源、任务、证据…"></label><small>本周剩余 4h 20m</small><b class="operator-avatar">我</b></div>
+            </header>
+            <main class="app-content">{% block content %}{% endblock %}</main>
+        </section>
+    </div>
 </body>
 </html>
diff --git a/apps/web/templates/dashboard.html b/apps/web/templates/dashboard.html
index 6e73736..92417b4 100644
--- a/apps/web/templates/dashboard.html
+++ b/apps/web/templates/dashboard.html
@@ -1,51 +1,57 @@
 {% extends "base.html" %}
-{% block title %}Dashboard{% endblock %}
+{% block title %}采集工作台{% endblock %}
 
 {% block content %}
-<p class="eyebrow">Personal evidence operations</p>
-<h1>Reality Workbench</h1>
-<p>先处理现实观察、最强异议和最小下一步；来源、条目和运行数量只在需要排障时展开，不能替代需求判断。</p>
+<p class="eyebrow">需求挖掘 · 最小可用闭环</p>
+<h1>采集工作台</h1>
+<p>从定义信源开始，采集公开内容，保留原文上下文，再把值得研究的内容送入需求分析。这里不替你联系任何人，也不把评论当作已被验证的需求。</p>
 
-<article id="today-workspace">
-    <header><strong>Today: reality-facing work</strong></header>
-    <p>Loading the current evidence, objection, and smallest next action…</p>
-</article>
+<section id="collection-workbench" class="workbench-grid">
+    <article>
+        <header><strong>1. 定义信源</strong></header>
+        <p>添加一个你要持续关注的平台、社区或内容入口，并配置采集频率与边界。</p>
+        <a href="/sources/create" role="button">Define a source</a>
+    </article>
+    <article>
+        <header><strong>2. 配置并执行采集</strong></header>
+        <p>为选定信源固定采集配置，先预览，再由你决定是否执行有限范围的公开采集。</p>
+        <a href="/missions" role="button" class="secondary">Open collection workbench</a>
+    </article>
+    <article>
+        <header><strong>3. 审阅证据候选</strong></header>
+        <p>只有带原文与上下文的内容才能进入需求判断；接受、忽略或标记待查都保留理由。</p>
+        <a href="/missions#evidence-inbox" role="button" class="secondary outline">Review collected evidence</a>
+    </article>
+</section>
 
-<h2>Start from reality</h2>
-<div class="grid">
-    <a href="/observations" role="button">Record an observation</a>
-    <a href="/missions" role="button" class="secondary">Plan a bounded mission</a>
-    <a href="/sources" role="button" class="secondary outline">Review sources and configuration</a>
-</div>
+<article id="recent-evidence">
+    <header><strong>最近采集到的证据候选</strong></header>
+    <p>Loading…</p>
+</article>
 
 <article>
-    <header><strong>What this workbench does not claim</strong></header>
-    <p>A collected comment, an Agent proposal, an ontology relationship, or a finished Feature is not proof of demand, payment, retention, or profit. Each must remain traceable to observations, counterevidence, and a next reality action.</p>
+    <header><strong>这一步的完成标准</strong></header>
+    <p>你能独立完成一次：创建信源 → 固定配置 → 预览或执行采集 → 查看原始上下文 → 做出证据处置。需求假设与产品定义在此之后再进入下一步。</p>
 </article>
 
 <script>
-async function loadTodayWorkspace() {
-    const container = document.getElementById('today-workspace');
+const escapeHtml = (value) => String(value ?? '').replace(/[&<>'"]/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;',"'":'&#39;','"':'&quot;'}[c]));
+
+async function loadRecentEvidence() {
+    const target = document.getElementById('recent-evidence');
     try {
-        const response = await fetch('/api/today');
-        const today = await response.json();
-        const activeNeed = today.active_need
-            ? `<a href="/needs/${encodeURIComponent(today.active_need.id)}">${today.active_need.title}</a>`
-            : 'No active Need Issue';
-        container.innerHTML = `<header><strong>Today: reality-facing work</strong></header>
-            <p><strong>Next reality action:</strong> ${today.next_reality_action}</p>
-            <p><strong>Strongest objection:</strong> ${today.strongest_objection}</p>
-            <p><strong>Active Need:</strong> ${activeNeed}</p>
-            <p><strong>Active validation:</strong> ${today.active_validation
-                ? `${today.active_validation.status} · ${today.active_validation.stop_condition}`
-                : 'None'}</p>
-            <p><strong>WIP:</strong> validations ${today.wip.validations.active}/${today.wip.validations.limit}; builds ${today.wip.builds_or_paid_pilots.active}/${today.wip.builds_or_paid_pilots.limit}</p>
-            <small>Recorded outcomes: ${today.recorded_outcomes}. Counts do not establish success.</small>`;
+        const response = await fetch('/api/evidence-inbox?page=1&page_size=3');
+        const data = await response.json();
+        if (!response.ok) throw new Error(data.detail || 'Could not load evidence inbox.');
+        const items = data.items || [];
+        target.innerHTML = `<header><strong>最近采集到的证据候选</strong></header>${items.length
+            ? `<div class="evidence-list">${items.map((item) => `<p><strong>${escapeHtml(item.source_label)}</strong> · ${escapeHtml(item.status)}<br><small>${escapeHtml(item.observation)}</small></p>`).join('')}</div><a href="/missions#evidence-inbox">打开完整证据收件箱</a>`
+            : '<p>尚无候选证据。先定义一个信源并执行一次小范围采集。</p>'}`;
     } catch (error) {
-        container.innerHTML = '<p class="failure-detail">Could not load today workspace.</p>';
+        target.innerHTML = '<p class="failure-detail">暂时无法读取证据收件箱。</p>';
     }
 }
 
-loadTodayWorkspace();
+loadRecentEvidence();
 </script>
 {% endblock %}
diff --git a/apps/web/templates/missions/workbench.html b/apps/web/templates/missions/workbench.html
index 4b88a82..65be934 100644
--- a/apps/web/templates/missions/workbench.html
+++ b/apps/web/templates/missions/workbench.html
@@ -2,86 +2,97 @@
 {% block title %}Mission Workbench{% endblock %}
 
 {% block content %}
-<header class="workbench-heading">
+<header class="workbench-heading collection-heading">
     <div>
-        <p class="eyebrow">Evidence acquisition</p>
-        <h1>Mission Workbench</h1>
-        <p>把一个现实问题约束成可复核的采集任务。这里产出的是证据候选，不是已经成立的需求。</p>
+        <p class="eyebrow">现实采集 / 采集控制台</p>
+        <h1>现实采集工作台</h1>
+        <p>管理“为什么采、从哪里采、采到什么程度”，而不是启动一个黑箱爬虫。</p>
     </div>
-    <a href="/sources/create" role="button" class="secondary">Create source</a>
+    <div class="head-actions"><a href="/sources/create" role="button" class="secondary">导入材料</a><button type="button" onclick="document.getElementById('mission-editor').scrollIntoView({behavior: 'smooth', block: 'start'}); document.getElementById('reality-question').focus();">＋ 新建采集任务</button></div>
 </header>
 
 <div id="workbench-message" role="status" aria-live="polite"></div>
 
-<section class="workbench-grid">
+<nav class="collection-tabs" aria-label="采集工作台分区">
+    <button type="button" class="active">控制台</button><a href="/sources">采集源 <small>12</small></a><button type="button">采集任务 <small>5</small></button><button type="button">运行队列 <small>3</small></button><a href="#evidence-inbox">信号收件箱 <small>48</small></a><button type="button">上下文修复 <small>6</small></button><button type="button">质量审计</button>
+</nav>
+
+<article class="cold-water-notice"><strong>冷水提醒</strong><span>采集量不是证据强度。重复的同源评论不会自动变成独立需求。</span><a href="/portfolio">检查信源组合 →</a></article>
+
+<div id="collection-layout">
+<aside id="source-panel" class="collection-panel">
     <article>
-        <header><strong>1. Select an active source</strong></header>
-        <label for="source-id">Source</label>
+        <header><strong>采集源</strong><small>活跃来源</small></header>
+        <label for="source-id">选择来源</label>
         <select id="source-id" required>
-            <option value="">Loading active sources…</option>
+            <option value="">正在加载可用信源…</option>
         </select>
-        <small id="source-summary">Only an explicitly selected source can be configured or run.</small>
+        <small id="source-summary">选择一个来源，再定义它本次的采集边界。</small>
+        <a href="/sources" role="button" class="secondary outline source-library-link">管理全部采集源</a>
     </article>
+</aside>
 
+<section id="mission-editor" class="collection-panel">
     <article>
-        <header><strong>2. Pin a collection configuration</strong></header>
-        <p><small>A mission always records an immutable configuration version. Adjusting this form creates a new version; it never rewrites an old run.</small></p>
+        <header><strong>任务定义</strong><small>草稿 · 自动保存</small></header>
+        <h2>固定采集配置</h2>
+        <p><small>每次采集都固定一版配置。修改会创建新版本，不会改写既有运行记录。</small></p>
         <form id="source-config-form">
             <div class="grid">
-                <label>Access mode
+                <label>访问方式
                     <select id="access-mode"><option value="public">Public</option><option value="rate_limited">Rate limited</option><option value="credentialed">Credentialed</option><option value="subscription">Subscription</option></select>
                 </label>
-                <label>Parser
+                <label>解析器
                     <input id="parser" value="github_issue" required>
                 </label>
             </div>
-            <label>Query terms <small>(one per line)</small>
+            <label>检索词 <small>（每行一个）</small>
                 <textarea id="config-query-terms" rows="3" required>user pain
 workaround</textarea>
             </label>
             <div class="grid">
-                <label>Request limit<input id="request-limit" type="number" min="1" value="2" required></label>
-                <label>Timeout (seconds)<input id="timeout-seconds" type="number" min="1" value="15" required></label>
-                <label>Page limit<input id="page-limit" type="number" min="1" value="1" required></label>
+                <label>请求上限<input id="request-limit" type="number" min="1" value="2" required></label>
+                <label>超时（秒）<input id="timeout-seconds" type="number" min="1" value="15" required></label>
+                <label>页数上限<input id="page-limit" type="number" min="1" value="1" required></label>
             </div>
-            <button type="submit" class="secondary">Create and pin config version</button>
+            <button type="submit">保存采集配置</button>
         </form>
         <p id="pinned-config" class="config-status">No configuration version pinned.</p>
     </article>
-</section>
+    </article>
 
-<article>
-    <header><strong>3. Define a bounded reality question</strong></header>
+    <article>
+    <header><strong>本次采集要回答的问题</strong></header>
     <form id="mission-form">
         <div class="grid">
-            <label>Mission type
+            <label>任务类型
                 <select id="mission-type"><option value="targeted_evidence">Targeted evidence</option><option value="exploratory">Exploratory</option><option value="counterevidence">Counterevidence</option><option value="context_repair">Context repair</option></select>
             </label>
-            <label>Target audience<input id="target-audience" value="independent developers" required></label>
+            <label>目标人群<input id="target-audience" value="独立开发者" required></label>
         </div>
-        <label>Reality question
-            <textarea id="reality-question" rows="2" required>What observable cost or repeated workaround is this audience describing?</textarea>
+        <label>现实问题 / 证据缺口
+            <textarea id="reality-question" rows="2" required>这个人群正在描述什么可观察的成本或重复性替代做法？</textarea>
         </label>
         <div class="grid">
-            <label>Regions <small>(one per line)</small><textarea id="regions" rows="2" required>global</textarea></label>
-            <label>Languages <small>(one per line)</small><textarea id="languages" rows="2" required>en</textarea></label>
-            <label>Query seeds <small>(one per line)</small><textarea id="query-seeds" rows="2" required>user pain
+            <label>区域 <small>（每行一个）</small><textarea id="regions" rows="2" required>全球</textarea></label>
+            <label>语言 <small>（每行一个）</small><textarea id="languages" rows="2" required>英语</textarea></label>
+            <label>检索种子 <small>（每行一个）</small><textarea id="query-seeds" rows="2" required>user pain
 workaround</textarea></label>
         </div>
         <div class="grid">
-            <label>Time budget (minutes)<input id="time-budget" type="number" min="1" value="30" required></label>
-            <label>Item limit<input id="item-limit" type="number" min="1" value="20" required></label>
-            <label>Cost budget (cents)<input id="cost-budget" type="number" min="0" value="0" required></label>
+            <label>时间预算（分钟）<input id="time-budget" type="number" min="1" value="30" required></label>
+            <label>材料上限<input id="item-limit" type="number" min="1" value="20" required></label>
+            <label>成本预算（分）<input id="cost-budget" type="number" min="0" value="0" required></label>
         </div>
-        <label>Stop conditions <small>(one per line; must say when evidence is enough)</small>
-            <textarea id="stop-conditions" rows="2" required>Collect independent observations with original context</textarea>
+        <label>停止条件 <small>（每行一个；必须明确何时足够）</small>
+            <textarea id="stop-conditions" rows="2" required>收集带原始上下文的独立观察</textarea>
         </label>
-        <button id="create-mission" type="submit" disabled>Create bounded mission</button>
+        <button id="create-mission" type="submit" disabled>保存采集任务</button>
     </form>
-</article>
+    </article>
 
 <article id="execution-panel" hidden>
-    <header><strong>4. Preview, then execute explicitly</strong></header>
+    <header><strong>试运行，再执行</strong></header>
     <div class="grid">
         <label>Execution mode
             <select id="execution-mode">
@@ -101,22 +112,26 @@ <h1>Mission Workbench</h1>
         <button id="queue-mission" type="button">Queue selected mode</button>
     </div>
 </article>
+</section>
 
+<aside id="operation-rail" class="collection-panel">
 <section id="mission-result" aria-live="polite">
-    <p><em>No mission has been created in this session.</em></p>
+    <p><em>本次尚未创建采集任务。</em></p>
 </section>
 
-<section>
-    <header class="section-heading"><div><p class="eyebrow">Persistent collection assets</p><h2>Mission and run history</h2></div><button id="refresh-missions" type="button" class="secondary outline">Refresh</button></header>
+<section class="rail-history">
+    <header class="section-heading"><div><p class="eyebrow">持续积累的采集资产</p><h2>任务与运行记录</h2></div><button id="refresh-missions" type="button" class="secondary outline">刷新</button></header>
     <p><small>Saved missions and previews remain visible after a browser refresh. A preview is retained for audit, but it never creates candidate evidence.</small></p>
     <div id="mission-history"><p>Loading mission history…</p></div>
 </section>
 
-<section>
-    <header class="section-heading"><div><p class="eyebrow">Candidate evidence</p><h2>Evidence Inbox</h2></div><button id="refresh-evidence" type="button" class="secondary outline">Refresh</button></header>
+<section class="rail-inbox">
+    <header class="section-heading"><div><p class="eyebrow">候选证据</p><h2>信号收件箱</h2></div><button id="refresh-evidence" type="button" class="secondary outline">刷新</button></header>
     <p><small>Candidate evidence may be incomplete or misleading. It is not a validated demand and must be reviewed with its original material and lineage.</small></p>
     <div id="evidence-inbox"><p>Loading Evidence Inbox…</p></div>
 </section>
+</aside>
+</div>
 
 <script>
 const state = { source: null, config: null, mission: null, run: null };
diff --git a/apps/web/templates/objectives/workspace.html b/apps/web/templates/objectives/workspace.html
new file mode 100644
index 0000000..c24956e
--- /dev/null
+++ b/apps/web/templates/objectives/workspace.html
@@ -0,0 +1,217 @@
+{% extends "base.html" %}
+
+{% block title %}Discovery Objective{% endblock %}
+{% block breadcrumb %}需求挑战 / <strong>发现目标</strong>{% endblock %}
+
+{% block content %}
+<section id="objective-workspace" data-objective-id="{{ objective_id }}">
+    <p class="eyebrow">DISCOVERY OBJECTIVE</p>
+    <h1 id="objective-title">正在加载发现目标…</h1>
+    <p id="objective-question"></p>
+    <p id="objective-status" role="status"></p>
+
+    <article>
+        <header><strong>Approved collection boundary</strong><small id="boundary-version"></small></header>
+        <dl id="boundary-details"></dl>
+    </article>
+
+    <article>
+        <header><strong>停止条件</strong></header>
+        <div class="grid">
+            <section><small>资源</small><ul id="resource-stop-conditions"></ul></section>
+            <section><small>证据</small><ul id="evidence-stop-conditions"></ul></section>
+            <section><small>决策</small><ul id="decision-stop-conditions"></ul></section>
+        </div>
+    </article>
+
+    <article id="assessments-panel">
+        <header><strong>Evidence-cited Assessment</strong></header>
+        <p>这是智能体或操作员基于证据的判断，不是已验证的市场需求。</p>
+        <ul id="assessments"></ul>
+        <p>当前最强反证（按评估强度排序，不等同于市场事实）</p>
+        <p id="strongest-counterevidence">尚无已记录反证。</p>
+        <p>尚未解决的未知项</p>
+        <ul id="assessment-unknowns"></ul>
+        <p>Need Hypothesis（仅草稿）</p>
+        <ul id="need-hypotheses"></ul>
+    </article>
+
+    <article>
+        <header><strong>采集计划</strong></header>
+        <ul id="acquisition-plans"></ul>
+        <p><a id="mission-console-link" href="/missions">进入采集控制台执行已批准计划 →</a></p>
+    </article>
+
+    <article id="agent-runs-panel">
+        <header><strong>受控 Discovery Agent 运行</strong></header>
+        <p>每次运行绑定当时的目标、边界、证据包和预算；边界变化后不得继续执行。</p>
+        <ul id="agent-runs"></ul>
+        <p>Agent 草案（仍需人工审阅，不会自动成为结论或计划）</p>
+        <ul id="agent-proposals"></ul>
+    </article>
+
+    <article id="mission-console-region">
+        <header><strong>采集控制台</strong></header>
+        <p>这是既有 Mission / Run 操作面；它保留独立控制台的采集、暂停、取消、重试与回放能力。</p>
+        <iframe
+            title="SourceOS 采集控制台"
+            src="/missions"
+            loading="lazy"
+            style="width: 100%; min-height: 760px; border: 0;"
+        ></iframe>
+    </article>
+
+    <article id="evidence-panel">
+        <header><strong>证据包</strong></header>
+        <p>候选证据不是需求结论，必须回看原始材料与上下文。</p>
+        <ul id="workspace-evidence"></ul>
+    </article>
+
+    <article id="approval-panel">
+        <header><strong>操作员审批与边界修订</strong></header>
+        <p>待批准请求</p>
+        <ul id="pending-approvals"></ul>
+        <div id="approval-actions" hidden></div>
+        <p>边界修订</p>
+        <ul id="boundary-revisions"></ul>
+        <form id="boundary-revision-form" hidden>
+            <label>修订理由<input name="reason" required></label>
+            <label>新增请求上限<input name="request_limit" type="number" min="1" required></label>
+            <button>以新边界恢复目标</button>
+        </form>
+    </article>
+
+    <article id="decision-record-panel" hidden>
+        <header><strong>决策记录与结果反馈</strong></header>
+        <p id="decision-record-summary"></p>
+        <p><small>结果反馈只用于校准下一次判断；它不是市场已验证，也不是智能体评分。</small></p>
+        <ul id="outcome-feedback"></ul>
+    </article>
+
+    <p id="objective-error" hidden></p>
+</section>
+<script>
+    const objectiveId = document.querySelector('#objective-workspace').dataset.objectiveId;
+    const renderList = (selector, values) => {
+        document.querySelector(selector).replaceChildren(...values.map((value) => {
+            const item = document.createElement('li'); item.textContent = value; return item;
+        }));
+    };
+    async function loadObjectiveWorkspace() {
+        const response = await fetch(`/api/discovery-objectives/${objectiveId}/workspace`);
+        if (!response.ok) throw new Error('Discovery Objective could not be loaded');
+        const workspace = await response.json();
+        const { objective, current_boundary: boundary } = workspace;
+        document.querySelector('#objective-title').textContent = objective.title;
+        document.querySelector('#objective-question').textContent = objective.question;
+        document.querySelector('#objective-status').textContent = `状态：${objective.status}`;
+        document.querySelector('#boundary-version').textContent = `v${boundary.version}`;
+        document.querySelector('#boundary-details').innerHTML = '';
+        for (const [label, value] of Object.entries({
+            '来源': boundary.approved_source_ids.join(', '), '工具': boundary.tool_allowlist.join(', '),
+            '请求上限': boundary.request_limit, '时间预算（分钟）': boundary.time_budget_minutes,
+            '成本预算（分）': boundary.cost_budget_cents,
+        })) {
+            const term = document.createElement('dt'); term.textContent = label;
+            const definition = document.createElement('dd'); definition.textContent = value;
+            document.querySelector('#boundary-details').append(term, definition);
+        }
+        renderList('#resource-stop-conditions', objective.resource_stop_conditions);
+        renderList('#evidence-stop-conditions', objective.evidence_stop_conditions);
+        renderList('#decision-stop-conditions', objective.decision_stop_conditions);
+        renderList(
+            '#pending-approvals',
+            workspace.pending_approvals.map((approval) => `${approval.request_type}: ${approval.reason}`),
+        );
+        renderList(
+            '#boundary-revisions',
+            workspace.boundary_revisions.map((revision) => `v${revision.boundary_version}: ${revision.reason}`),
+        );
+        renderList(
+            '#acquisition-plans',
+            workspace.plans.map((plan) => {
+                const runCount = Object.values(plan.mission_runs).flat().length;
+                const revision = plan.revision ? ` · 差异：${plan.revision.reason}` : '';
+                return `v${plan.version}: ${plan.question} · ${plan.missions.length} missions / ${runCount} runs${revision}`;
+            }),
+        );
+        renderList(
+            '#assessments',
+            workspace.assessments.map((assessment) => `${assessment.kind}: ${assessment.statement} · 引用：${assessment.evidence_ids.join(', ') || assessment.assessment_ids.join(', ')}`),
+        );
+        const strengthRank = {unknown: 0, weak: 1, moderate: 2, strong: 3};
+        const counterevidence = workspace.assessments
+            .filter((assessment) => assessment.kind === 'counterevidence')
+            .sort((left, right) => strengthRank[right.evidence_strength] - strengthRank[left.evidence_strength])[0];
+        document.querySelector('#strongest-counterevidence').textContent = counterevidence
+            ? `${counterevidence.statement} · 评估强度：${counterevidence.evidence_strength} · 引用：${counterevidence.evidence_ids.join(', ')}`
+            : '尚无已记录反证。';
+        renderList(
+            '#assessment-unknowns',
+            workspace.assessments.flatMap((assessment) => assessment.unknowns),
+        );
+        renderList(
+            '#need-hypotheses',
+            workspace.need_hypotheses.map((hypothesis) => `${hypothesis.status}: ${hypothesis.title}`),
+        );
+        renderList(
+            '#agent-runs',
+            workspace.agent_runs.map((run) => `${run.status}: ${run.prompt_version} · boundary v${run.boundary_version}`),
+        );
+        renderList(
+            '#agent-proposals',
+            workspace.agent_runs.map((run) => {
+                const proposal = run.output?.proposal;
+                if (!proposal) return `${run.status}: 尚无可审阅草案。`;
+                const summary = proposal.statement || proposal.reason || '未提供摘要';
+                const citations = proposal.evidence_ids?.join(', ') || '无证据引用';
+                return `${proposal.contract}: ${summary} · 引用：${citations} · 状态：${proposal.status || 'unknown'}`;
+            }),
+        );
+        renderList(
+            '#workspace-evidence',
+            workspace.evidence_bundle.map((evidence) => `${evidence.source_label}: ${evidence.observation}`),
+        );
+        const decisionPanel = document.querySelector('#decision-record-panel');
+        decisionPanel.hidden = workspace.decision_record === null;
+        if (workspace.decision_record) {
+            const record = workspace.decision_record;
+            document.querySelector('#decision-record-summary').textContent =
+                `${record.decision}: ${record.reason}`;
+            renderList(
+                '#outcome-feedback',
+                record.outcomes.map((outcome) => `${outcome.kind}: ${outcome.summary} (${outcome.reference})`),
+            );
+        }
+        const actions = document.querySelector('#approval-actions');
+        actions.hidden = objective.status !== 'pending_approval';
+        actions.replaceChildren(...workspace.pending_approvals.flatMap((approval) => {
+            const approve = document.createElement('button'); approve.textContent = `批准 ${approval.request_type}`;
+            approve.onclick = () => approveApproval(approval.id, 'approve');
+            const reject = document.createElement('button'); reject.textContent = `拒绝 ${approval.request_type}`;
+            reject.onclick = () => approveApproval(approval.id, 'reject');
+            return [approve, reject];
+        }));
+        document.querySelector('#boundary-revision-form').hidden = objective.status !== 'blocked';
+    }
+    async function approveApproval(approvalId, decision) {
+        const reason = window.prompt('记录理由'); if (!reason) return;
+        await fetch(`/api/discovery-objectives/${objectiveId}/approvals/${approvalId}/${decision}`, {
+            method: 'POST', headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({operator: 'owner', reason}),
+        });
+        await loadObjectiveWorkspace();
+    }
+    document.querySelector('#boundary-revision-form').onsubmit = async (event) => {
+        event.preventDefault(); const data = new FormData(event.currentTarget);
+        await fetch(`/api/discovery-objectives/${objectiveId}/boundary-revisions`, {
+            method: 'POST', headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({operator: 'owner', reason: data.get('reason'), boundary_patch: {request_limit: Number(data.get('request_limit'))}}),
+        });
+        await loadObjectiveWorkspace();
+    };
+    loadObjectiveWorkspace().catch((error) => {
+        const target = document.querySelector('#objective-error'); target.hidden = false; target.textContent = error.message;
+    });
+</script>
+{% endblock %}
diff --git a/docs/adr/0001-bounded-discovery-agent-authority.md b/docs/adr/0001-bounded-discovery-agent-authority.md
new file mode 100644
index 0000000..fd14260
--- /dev/null
+++ b/docs/adr/0001-bounded-discovery-agent-authority.md
@@ -0,0 +1,3 @@
+# Bound the Discovery Agent to approved public collection
+
+SourceOS will use a Discovery Agent that may plan and execute collection only inside an Approved Collection Boundary: approved public sources, allowlisted tools, and fixed request, time, and cost limits. The operator must approve any source or boundary change, credentialed or subscription access, budget expansion, external contact, publication, product commitment, or development authorization; this preserves autonomous learning where it is cheap and reversible without delegating irreversible business decisions.
diff --git a/docs/adr/0002-make-discovery-objectives-agent-work-units.md b/docs/adr/0002-make-discovery-objectives-agent-work-units.md
new file mode 100644
index 0000000..d367e87
--- /dev/null
+++ b/docs/adr/0002-make-discovery-objectives-agent-work-units.md
@@ -0,0 +1,3 @@
+# Make Discovery Objectives the Agent's continuing work unit
+
+SourceOS will place a Discovery Objective above Acquisition Plans and Acquisition Missions. The operator owns the Objective and its falsification and stop conditions; the Discovery Agent proposes versioned Plans, and approved Plans create bounded Missions and Runs. This separates enduring business uncertainty from disposable collection mechanics, allowing evidence and counterevidence to change the next plan without rewriting the original question.
diff --git a/docs/adr/0003-allow-evidence-based-plan-revision-within-boundaries.md b/docs/adr/0003-allow-evidence-based-plan-revision-within-boundaries.md
new file mode 100644
index 0000000..71e8f82
--- /dev/null
+++ b/docs/adr/0003-allow-evidence-based-plan-revision-within-boundaries.md
@@ -0,0 +1,3 @@
+# Allow evidence-based plan revision inside approved boundaries
+
+The Discovery Agent may revise an Acquisition Plan without another approval only when the revision remains within the current Approved Collection Boundary. Every Plan Revision must record its predecessor, the supporting evidence or coverage gap, and the resulting mission changes; adding a source, credential, budget, external contact, product commitment, or development action still requires Operator Approval.
diff --git a/docs/adr/0004-separate-agent-assessments-from-business-decisions.md b/docs/adr/0004-separate-agent-assessments-from-business-decisions.md
new file mode 100644
index 0000000..445572b
--- /dev/null
+++ b/docs/adr/0004-separate-agent-assessments-from-business-decisions.md
@@ -0,0 +1,3 @@
+# Separate Agent Assessments from business decisions
+
+SourceOS will automatically persist evidence candidates, Discovery Assessments, and Need Hypothesis drafts, each with source lineage and version history. Only the operator may promote a Need Hypothesis into a Need Issue, create a Product Thesis, authorize development, or make an external commercial commitment; the system must never treat an Agent-generated conclusion as evidence of demand.
diff --git a/docs/adr/0005-make-stopping-and-blocked-assessments-first-class.md b/docs/adr/0005-make-stopping-and-blocked-assessments-first-class.md
new file mode 100644
index 0000000..7ac0033
--- /dev/null
+++ b/docs/adr/0005-make-stopping-and-blocked-assessments-first-class.md
@@ -0,0 +1,3 @@
+# Make stopping and Blocked Assessments first-class
+
+Every Discovery Objective will carry resource, evidence, and decision stop conditions. When no defensible next Acquisition Plan exists inside the remaining boundary and budget, the Discovery Agent must emit a Blocked Assessment that names the unknowns and required new information or approval rather than silently expanding collection or looping indefinitely.
diff --git a/docs/adr/0006-limit-first-agent-to-discovery-and-judgment.md b/docs/adr/0006-limit-first-agent-to-discovery-and-judgment.md
new file mode 100644
index 0000000..50162ac
--- /dev/null
+++ b/docs/adr/0006-limit-first-agent-to-discovery-and-judgment.md
@@ -0,0 +1,3 @@
+# Limit the first Agent to discovery and judgment
+
+The first SourceOS Agent will collect, assess, revise discovery plans, and draft Need Hypotheses; it may read Outcome Feedback from delivered products and services to calibrate future discovery. It will not create development work, merge code, release products, set prices, contact customers, sell, or collect payment, because proving discovery quality is the first product loop and must not be obscured by a full-lifecycle automation project.
diff --git a/docs/adr/0007-make-objective-workspaces-the-primary-interface.md b/docs/adr/0007-make-objective-workspaces-the-primary-interface.md
new file mode 100644
index 0000000..7160fc0
--- /dev/null
+++ b/docs/adr/0007-make-objective-workspaces-the-primary-interface.md
@@ -0,0 +1,3 @@
+# Make Discovery Objective Workspaces the primary interface
+
+SourceOS will organize the first Agent product around Discovery Objective Workspaces rather than a generic dashboard or chat window. The Workspace exposes the current Assessment, counterevidence, unknowns, plan revisions, approved runs, evidence lineage, and operator decisions; conversation may assist inspection but cannot replace visible control of boundaries and business decisions.
diff --git a/docs/adr/0008-calibrate-discovery-from-decision-records-and-outcomes.md b/docs/adr/0008-calibrate-discovery-from-decision-records-and-outcomes.md
new file mode 100644
index 0000000..ebeceb1
--- /dev/null
+++ b/docs/adr/0008-calibrate-discovery-from-decision-records-and-outcomes.md
@@ -0,0 +1,3 @@
+# Calibrate discovery from Decision Records and Outcome Feedback
+
+SourceOS will close every completed, abandoned, or blocked Discovery Objective with a Discovery Decision Record and attach subsequent Outcome Feedback when it becomes available. It will not claim a global Agent accuracy score until enough real product and service outcomes exist; counts of collected material, generated plans, or model activity are operational telemetry rather than proof of discovery quality.
diff --git a/docs/adr/0009-reactivate-blocked-objectives-only-through-boundary-revisions.md b/docs/adr/0009-reactivate-blocked-objectives-only-through-boundary-revisions.md
new file mode 100644
index 0000000..f419578
--- /dev/null
+++ b/docs/adr/0009-reactivate-blocked-objectives-only-through-boundary-revisions.md
@@ -0,0 +1,3 @@
+# Reactivate blocked Objectives only through Boundary Revisions
+
+SourceOS will not support a bare “reopen” action for blocked Discovery Objectives. An operator must create an Operator Boundary Revision that explicitly changes a source, budget, time, tool, or evidence condition and records the reason; only that revision may activate a new Acquisition Plan, preventing a nominal restart that cannot legally perform any new action.
diff --git "a/docs/specifications/20260803-14\357\274\23215-DiscoveryObjective\346\231\272\350\203\275\344\275\223\345\217\221\347\216\260\345\267\245\344\275\234\345\217\260\344\272\247\345\223\201\344\270\216\346\212\200\346\234\257\350\247\204\346\240\274-gpt-5-v0.1.md" "b/docs/specifications/20260803-14\357\274\23215-DiscoveryObjective\346\231\272\350\203\275\344\275\223\345\217\221\347\216\260\345\267\245\344\275\234\345\217\260\344\272\247\345\223\201\344\270\216\346\212\200\346\234\257\350\247\204\346\240\274-gpt-5-v0.1.md"
new file mode 100644
index 0000000..6a892e7
--- /dev/null
+++ "b/docs/specifications/20260803-14\357\274\23215-DiscoveryObjective\346\231\272\350\203\275\344\275\223\345\217\221\347\216\260\345\267\245\344\275\234\345\217\260\344\272\247\345\223\201\344\270\216\346\212\200\346\234\257\350\247\204\346\240\274-gpt-5-v0.1.md"
@@ -0,0 +1,91 @@
+# Discovery Objective 智能体发现工作台：产品与技术规格
+
+## Problem Statement
+
+SourceOS 当前以人工创建 `Acquisition Mission`、独立运行 worker、Pi 仅对固定证据包提出建议的传统 Web 工作流组织能力。经营者无法把一个长期现实不确定性作为 Agent 的持续工作对象，也无法审阅 Agent 为什么改变采集计划、是否越过批准边界、何时应停止，以及后来产品结果是否校正了最初判断。
+
+经营者需要一个以 `Discovery Objective` 为中心的工作台：让 Discovery Agent 在明确的批准边界内自主采集、补全上下文、寻找反证与修订计划；让不可逆或扩大权限的动作明确等待经营者批准；让每一个结论保留证据链，而不把模型输出伪装成真实需求、付费或利润。
+
+## Solution
+
+引入 `Discovery Objective Workspace` 作为 SourceOS 首版 Agent 产品的主界面和 API 聚合边界。经营者创建一个可证伪的 Discovery Objective 与初始 Approved Collection Boundary；Discovery Agent 生成版本化 Acquisition Plan，并在边界内驱动具体 Acquisition Mission 与 Run。每轮运行后它持久化 Evidence Candidate、Discovery Assessment、Need Hypothesis 草案与 Plan Revision；工作台呈现当前判断、最强反证、未知项、边界、待批准请求与合法下一步。
+
+Agent 仅能执行已批准公开信源内、受工具/请求/时间/成本约束的动作。它不能自动扩源、使用凭证、增加预算、联系任何人、创建 Need Issue、创建 Product Thesis、开发、发布、销售或收款。被阻塞的 Objective 不能裸重开；经营者必须创建有明确理由和增量的 Operator Boundary Revision，才能激活下一版计划。
+
+## User Stories
+
+1. As a solo operator, I want to create a falsifiable Discovery Objective, so that a long-lived business uncertainty is not confused with one collection job.
+2. As a solo operator, I want to state objective-level resource, evidence, and decision stop conditions, so that the Agent cannot research indefinitely.
+3. As a solo operator, I want to define an Approved Collection Boundary with approved public sources, allowlisted tools, and limits, so that autonomous collection remains reversible.
+4. As a solo operator, I want to see the boundary version that governed every plan and run, so that I can audit what the Agent was allowed to do at that time.
+5. As a Discovery Agent, I want to create an Acquisition Plan version with its question, source selection, counterevidence target, and bounded missions, so that my proposed action is reviewable before or after execution.
+6. As a Discovery Agent, I want to revise a plan after evidence reveals repetition, weak independence, or missing context, so that I can adapt without silently changing scope.
+7. As a solo operator, I want every Plan Revision to show its predecessor and cited reason, so that I can distinguish learning from arbitrary retuning.
+8. As a Discovery Agent, I want to create and execute an Acquisition Mission only within the current approved boundary, so that I cannot expand collection authority implicitly.
+9. As a solo operator, I want existing Mission Runs and their raw artifacts to remain immutable and linked to the Objective and Plan, so that results remain reproducible.
+10. As a solo operator, I want candidate evidence to retain original material, context, source URI, lineage, and run linkage, so that I can inspect what the Agent actually observed.
+11. As a Discovery Agent, I want to emit a Discovery Assessment containing support, counterevidence, unknowns, coverage gaps, and a next-plan recommendation, so that a conclusion is separable from evidence.
+12. As a solo operator, I want an Assessment to cite evidence IDs explicitly, so that a persuasive narrative without evidence cannot drive the Objective.
+13. As a Discovery Agent, I want to draft a Need Hypothesis only when a support Assessment cites evidence, so that a hypothesis cannot appear from an uncited model assertion.
+14. As a solo operator, I want Need Hypotheses to remain drafts until I explicitly promote one, so that the system never auto-creates a Need Issue.
+15. As a solo operator, I want a requested new source, credential, tool, budget, time extension, or external action to appear as an Operator Approval, so that I control boundary expansion.
+16. As a solo operator, I want to approve or reject a requested boundary change with a reason, so that the decision is auditable and the Agent receives a clear next state.
+17. As a solo operator, I want a blocked Objective to reject all further Agent collection or planning actions, so that “stopped” is enforced rather than decorative UI text.
+18. As a solo operator, I want to reactivate a blocked Objective only through an Operator Boundary Revision that records a concrete new allowance, so that a restart has actual capacity to act.
+19. As a solo operator, I want to see a Blocked Assessment with the exact unknown, exhausted constraint, and required new approval, so that I know what I must decide rather than seeing “no result.”
+20. As a solo operator, I want the Workspace to center the current Assessment, strongest counterevidence, unknowns, active plan, running actions, evidence, and approvals, so that the Agent is controlled through an operating surface rather than chat alone.
+21. As a solo operator, I want chat or free-form instruction to remain secondary and unable to bypass the Workspace controls, so that natural-language interaction cannot evade permissions.
+22. As a solo operator, I want to close an Objective as promoted, rewritten, abandoned, or blocked, so that every discovery loop has an explicit decision state.
+23. As a solo operator, I want a Discovery Decision Record at closure, so that I can revisit the decision with cited support, counterevidence, resource use, and unresolved unknowns.
+24. As a solo operator, I want to attach later Outcome Feedback from product tracking, delivery, retention, payment, refund, or support, so that later reality calibrates discovery without being mistaken for automatic market proof.
+25. As a solo operator, I want to see that collection counts and model activity are telemetry rather than Agent accuracy, so that the product does not create false confidence.
+26. As a solo operator, I want existing Evidence Inbox, Need Issue, Product Thesis, Feature, and Delivery flows to remain available, so that the Agent layer evolves the product instead of discarding proven audit paths.
+
+## Implementation Decisions
+
+- Add durable domain entities: `DiscoveryObjective`, versioned `ApprovedCollectionBoundary`, versioned `AcquisitionPlan`, `PlanRevision`, `DiscoveryAssessment`, `NeedHypothesis`, `OperatorApproval`, `OperatorBoundaryRevision`, and `DiscoveryDecisionRecord`.
+- `DiscoveryObjective` owns the falsifiable question, operator-defined stop conditions, lifecycle status, and current boundary/plan references. `AcquisitionMission` remains a concrete bounded instruction, but belongs to an Acquisition Plan rather than acting as the top-level discovery object.
+- Objective lifecycle states are `active`, `pending_approval`, `blocked`, and `completed`. Legal transitions are restricted to:
+
+  ```text
+  active → pending_approval → active
+  active → blocked | completed
+  blocked → OperatorBoundaryRevision → active
+  completed → terminal
+  ```
+
+  This state machine is validated by the throwaway `prototype/discovery-agent-state-machine` branch; a bare reopen transition is forbidden.
+- A Boundary Revision is versioned and must name a material delta: source, tool, request budget, time budget, cost budget, or evidence condition. It retains a reason and operator attribution; only it may reactivate a blocked Objective.
+- Discovery Agent runtime is a bounded orchestrator. It receives Objective state and a read-only evidence bundle, returns structured proposals and Assessments, and invokes only allowlisted collection/context-repair tools inside the current boundary. It never receives unrestricted database authority.
+- Existing Pi proposal runtime is retained as a lower-level cognitive component but no longer represents the product’s full Agent model. The orchestration layer validates proposed actions, records tool audit events, creates allowed plans/missions, and refuses illegal transitions before a worker executes anything.
+- Existing source configuration versions, mission-run queues, cancellation checkpoints, raw artifacts, candidate signal lineage, Evidence Inbox triage, Need Issue promotion, Product Thesis, Feature, Delivery, and Outcome controls remain source-of-truth integrations. New models reference them by immutable IDs; they do not duplicate raw evidence.
+- `DiscoveryAssessment` has kind(s) for support, counterevidence, coverage gap, unknown, blocked, and decision recommendation. Every non-empty conclusion cites evidence or prior Assessments; a Need Hypothesis requires at least one cited support Assessment.
+- `NeedHypothesis` is distinct from a Need Issue. Promotion is an explicit operator endpoint/action and reuses the existing Need Issue evidence workflow; no Agent endpoint creates a Need Issue, Product Thesis, feature, delivery record, or external action automatically.
+- The primary public API seam is a Discovery Objective Workspace resource: create/read Objective, retrieve a single workspace projection, submit bounded Agent planning/execution requests, record/review approvals, create Boundary Revisions, list Assessments/Hypotheses, and close the Objective with a Decision Record. Existing Mission and Evidence APIs remain lower-level seams.
+- The primary Web seam is a `Discovery Objective Workspace` route that reads the workspace projection and exposes only legal controls. The existing visual collection console becomes the plan/run area inside this page; it is not discarded.
+- Workspace ordering is fixed by decision significance: objective and stop conditions; current Assessment, strongest counterevidence and unknowns; current Plan Revision; running/queued Missions; evidence; approvals; closure/Outcome Feedback. Chat is a secondary inspection/control aid, never the authority boundary.
+- Outcome Feedback is append-only, linked to a closed Decision Record, and intentionally does not generate a global Agent accuracy metric. It supports later calibration views only after real product/service outcomes exist.
+
+## Testing Decisions
+
+- Tests verify public behaviour and legal transitions, never ORM internals, prompt wording, or private helper calls.
+- Primary API seam: Discovery Objective Workspace endpoints. Tests must prove creation, workspace projection, allowed plan revision, denied out-of-bound action, approval/rejection, block, Boundary Revision reactivation, hypothesis evidence requirement, promotion boundary, closure, and append-only Outcome Feedback.
+- Primary Web seam: the Workspace route must expose the current decision state, cited evidence links, pending approvals, disabled/absent illegal actions, and the existing collection console as the plan/run region.
+- Existing mission-run API tests are prior art for bounded execution, durable queues, cancellation, replay, raw artifact lineage, and retry. Existing Agent Run API tests are prior art for immutable evidence bundles, idempotency, budgets, runtime failure, and operator decisions. Existing web workbench tests are prior art for stable HTML controls and public endpoint links.
+- State-machine cases from the prototype become behavioural tests: repeated source causes a cited plan revision; pending approval prevents further planning/execution; a new source cannot be used before approval; blocked rejects actions; only Boundary Revision restores capacity; a Need Hypothesis without cited support is rejected; later Outcome Feedback does not alter original evidence.
+- Migration tests create a fresh database and prove all legacy Mission/Run/Evidence/Need records remain queryable and linkable after the new Objective layer is introduced.
+
+## Out of Scope
+
+- Autonomous external contact, interviews, sales, marketing, publishing, payment collection, pricing, product release, code generation, PR creation, or merge authority.
+- Credentialed/subscription source access without a separately approved boundary and implementation.
+- A chat-first autonomous founder interface.
+- A global Agent accuracy, profitability, or market-demand score before sufficient real Outcome Feedback exists.
+- Replacing existing source adapters or adding broad multi-platform collection in this feature.
+- Migrating historical Missions into Objectives automatically; legacy records remain accessible and can be attached deliberately where appropriate.
+
+## Further Notes
+
+- The design decisions are captured in ADR-0001 through ADR-0009 and the root domain glossary.
+- The primary source for legal transition behaviour is the throwaway prototype branch `prototype/discovery-agent-state-machine`, especially its verdict document. The TUI must not ship as production code.
+- This specification establishes the first Agent loop only: discover and judge. Product delivery and commercial operations are feedback inputs, not Agent-owned actions in this scope.
diff --git a/packages/storage/migrations/versions/a0b1c2d3e405_add_agent_run_objective_boundary.py b/packages/storage/migrations/versions/a0b1c2d3e405_add_agent_run_objective_boundary.py
new file mode 100644
index 0000000..034b61f
--- /dev/null
+++ b/packages/storage/migrations/versions/a0b1c2d3e405_add_agent_run_objective_boundary.py
@@ -0,0 +1,43 @@
+"""link Agent Runs to immutable Discovery Objective boundaries
+
+Revision ID: a0b1c2d3e405
+Revises: f7a8b9c0d123
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "a0b1c2d3e405"
+down_revision: str | None = "f7a8b9c0d123"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("agent_runs", sa.Column("objective_id", sa.UUID(), nullable=True))
+    op.add_column("agent_runs", sa.Column("boundary_id", sa.UUID(), nullable=True))
+    op.add_column("agent_runs", sa.Column("boundary_version", sa.Integer(), nullable=True))
+    op.create_foreign_key(
+        "fk_agent_run_objective",
+        "agent_runs",
+        "discovery_objectives",
+        ["objective_id"],
+        ["id"],
+        ondelete="RESTRICT",
+    )
+    op.create_foreign_key(
+        "fk_agent_run_boundary",
+        "agent_runs",
+        "approved_collection_boundaries",
+        ["boundary_id"],
+        ["id"],
+        ondelete="RESTRICT",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_agent_run_boundary", "agent_runs", type_="foreignkey")
+    op.drop_constraint("fk_agent_run_objective", "agent_runs", type_="foreignkey")
+    op.drop_column("agent_runs", "boundary_version")
+    op.drop_column("agent_runs", "boundary_id")
+    op.drop_column("agent_runs", "objective_id")
diff --git a/packages/storage/migrations/versions/b2c3d4e5f607_add_discovery_decision_records.py b/packages/storage/migrations/versions/b2c3d4e5f607_add_discovery_decision_records.py
new file mode 100644
index 0000000..60946b8
--- /dev/null
+++ b/packages/storage/migrations/versions/b2c3d4e5f607_add_discovery_decision_records.py
@@ -0,0 +1,64 @@
+"""add immutable Discovery Decision Records and append-only outcome feedback
+
+Revision ID: b2c3d4e5f607
+Revises: a0b1c2d3e405
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "b2c3d4e5f607"
+down_revision: str | None = "a0b1c2d3e405"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "discovery_decision_records",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("objective_id", sa.UUID(), nullable=False),
+        sa.Column("decision", sa.String(length=16), nullable=False),
+        sa.Column("reason", sa.Text(), nullable=False),
+        sa.Column(
+            "support_assessment_ids", postgresql.JSONB(astext_type=sa.Text()), nullable=False
+        ),
+        sa.Column(
+            "counter_assessment_ids", postgresql.JSONB(astext_type=sa.Text()), nullable=False
+        ),
+        sa.Column("unknowns", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column("resource_usage", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(["objective_id"], ["discovery_objectives.id"], ondelete="RESTRICT"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("objective_id"),
+    )
+    op.create_table(
+        "outcome_feedback",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("decision_record_id", sa.UUID(), nullable=False),
+        sa.Column("kind", sa.String(length=32), nullable=False),
+        sa.Column("reference", sa.Text(), nullable=False),
+        sa.Column("summary", sa.Text(), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(
+            ["decision_record_id"], ["discovery_decision_records.id"], ondelete="CASCADE"
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("outcome_feedback")
+    op.drop_table("discovery_decision_records")
diff --git a/packages/storage/migrations/versions/c3d4e5f6a708_add_discovery_objective_foundation.py b/packages/storage/migrations/versions/c3d4e5f6a708_add_discovery_objective_foundation.py
new file mode 100644
index 0000000..9dd4165
--- /dev/null
+++ b/packages/storage/migrations/versions/c3d4e5f6a708_add_discovery_objective_foundation.py
@@ -0,0 +1,72 @@
+"""add Discovery Objective foundation
+
+Revision ID: c3d4e5f6a708
+Revises: b1c2d3e4f506
+Create Date: 2026-08-03 16:10:00
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "c3d4e5f6a708"
+down_revision: str | None = "b1c2d3e4f506"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "discovery_objectives",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("title", sa.String(length=200), nullable=False),
+        sa.Column("question", sa.Text(), nullable=False),
+        sa.Column(
+            "resource_stop_conditions", postgresql.JSONB(astext_type=sa.Text()), nullable=False
+        ),
+        sa.Column(
+            "evidence_stop_conditions", postgresql.JSONB(astext_type=sa.Text()), nullable=False
+        ),
+        sa.Column(
+            "decision_stop_conditions", postgresql.JSONB(astext_type=sa.Text()), nullable=False
+        ),
+        sa.Column("status", sa.String(length=24), nullable=False, server_default="active"),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_table(
+        "approved_collection_boundaries",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("objective_id", sa.UUID(), nullable=False),
+        sa.Column("version", sa.Integer(), nullable=False),
+        sa.Column("approved_source_ids", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column("tool_allowlist", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column("request_limit", sa.Integer(), nullable=False),
+        sa.Column("time_budget_minutes", sa.Integer(), nullable=False),
+        sa.Column("cost_budget_cents", sa.Integer(), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(["objective_id"], ["discovery_objectives.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("objective_id", "version", name="uq_boundary_objective_version"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("approved_collection_boundaries")
+    op.drop_table("discovery_objectives")
diff --git a/packages/storage/migrations/versions/c4d5e6f7a809_add_agent_run_input_context.py b/packages/storage/migrations/versions/c4d5e6f7a809_add_agent_run_input_context.py
new file mode 100644
index 0000000..88989e4
--- /dev/null
+++ b/packages/storage/migrations/versions/c4d5e6f7a809_add_agent_run_input_context.py
@@ -0,0 +1,25 @@
+"""record immutable Objective and Boundary input context for Agent Runs
+
+Revision ID: c4d5e6f7a809
+Revises: b2c3d4e5f607
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "c4d5e6f7a809"
+down_revision: str | None = "b2c3d4e5f607"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "agent_runs",
+        sa.Column("input_context", postgresql.JSONB(astext_type=sa.Text()), nullable=True),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("agent_runs", "input_context")
diff --git a/packages/storage/migrations/versions/d5e6f7a8b901_add_operator_approvals_and_boundary_revisions.py b/packages/storage/migrations/versions/d5e6f7a8b901_add_operator_approvals_and_boundary_revisions.py
new file mode 100644
index 0000000..4930d81
--- /dev/null
+++ b/packages/storage/migrations/versions/d5e6f7a8b901_add_operator_approvals_and_boundary_revisions.py
@@ -0,0 +1,90 @@
+"""add operator approvals and boundary revisions
+
+Revision ID: d5e6f7a8b901
+Revises: c3d4e5f6a708
+Create Date: 2026-08-03 16:35:00
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "d5e6f7a8b901"
+down_revision: str | None = "c3d4e5f6a708"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("discovery_objectives", sa.Column("block_reason", sa.Text(), nullable=True))
+    op.add_column(
+        "approved_collection_boundaries",
+        sa.Column(
+            "credential_scope",
+            postgresql.JSONB(astext_type=sa.Text()),
+            server_default=sa.text("'[]'::jsonb"),
+            nullable=False,
+        ),
+    )
+    op.add_column(
+        "approved_collection_boundaries",
+        sa.Column(
+            "evidence_conditions",
+            postgresql.JSONB(astext_type=sa.Text()),
+            server_default=sa.text("'[]'::jsonb"),
+            nullable=False,
+        ),
+    )
+    op.create_table(
+        "operator_approvals",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("objective_id", sa.UUID(), nullable=False),
+        sa.Column("request_type", sa.String(length=64), nullable=False),
+        sa.Column("reason", sa.Text(), nullable=False),
+        sa.Column(
+            "requested_boundary_patch", postgresql.JSONB(astext_type=sa.Text()), nullable=False
+        ),
+        sa.Column("status", sa.String(length=16), nullable=False, server_default="pending"),
+        sa.Column("operator", sa.String(length=120), nullable=True),
+        sa.Column("decision_reason", sa.Text(), nullable=True),
+        sa.Column("decided_at", sa.DateTime(timezone=True), nullable=True),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(["objective_id"], ["discovery_objectives.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_table(
+        "operator_boundary_revisions",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("objective_id", sa.UUID(), nullable=False),
+        sa.Column("boundary_id", sa.UUID(), nullable=False),
+        sa.Column("approval_id", sa.UUID(), nullable=True),
+        sa.Column("operator", sa.String(length=120), nullable=False),
+        sa.Column("reason", sa.Text(), nullable=False),
+        sa.Column("boundary_patch", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(
+            ["boundary_id"], ["approved_collection_boundaries.id"], ondelete="RESTRICT"
+        ),
+        sa.ForeignKeyConstraint(["approval_id"], ["operator_approvals.id"], ondelete="RESTRICT"),
+        sa.ForeignKeyConstraint(["objective_id"], ["discovery_objectives.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("approval_id"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("operator_boundary_revisions")
+    op.drop_table("operator_approvals")
+    op.drop_column("approved_collection_boundaries", "evidence_conditions")
+    op.drop_column("approved_collection_boundaries", "credential_scope")
+    op.drop_column("discovery_objectives", "block_reason")
diff --git a/packages/storage/migrations/versions/d6e7f8a9b012_add_agent_run_plan_link.py b/packages/storage/migrations/versions/d6e7f8a9b012_add_agent_run_plan_link.py
new file mode 100644
index 0000000..362d70f
--- /dev/null
+++ b/packages/storage/migrations/versions/d6e7f8a9b012_add_agent_run_plan_link.py
@@ -0,0 +1,30 @@
+"""link Agent Runs to the Plan they are allowed to assess or revise
+
+Revision ID: d6e7f8a9b012
+Revises: c4d5e6f7a809
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "d6e7f8a9b012"
+down_revision: str | None = "c4d5e6f7a809"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("agent_runs", sa.Column("acquisition_plan_id", sa.UUID(), nullable=True))
+    op.create_foreign_key(
+        "fk_agent_run_plan",
+        "agent_runs",
+        "acquisition_plans",
+        ["acquisition_plan_id"],
+        ["id"],
+        ondelete="RESTRICT",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_agent_run_plan", "agent_runs", type_="foreignkey")
+    op.drop_column("agent_runs", "acquisition_plan_id")
diff --git a/packages/storage/migrations/versions/e6f7a8b9c012_add_acquisition_plans.py b/packages/storage/migrations/versions/e6f7a8b9c012_add_acquisition_plans.py
new file mode 100644
index 0000000..92f7949
--- /dev/null
+++ b/packages/storage/migrations/versions/e6f7a8b9c012_add_acquisition_plans.py
@@ -0,0 +1,82 @@
+"""add Acquisition Plans linked to Discovery Objectives
+
+Revision ID: e6f7a8b9c012
+Revises: d5e6f7a8b901
+Create Date: 2026-08-03 17:05:00
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "e6f7a8b9c012"
+down_revision: str | None = "d5e6f7a8b901"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "acquisition_plans",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("objective_id", sa.UUID(), nullable=False),
+        sa.Column("boundary_id", sa.UUID(), nullable=False),
+        sa.Column("version", sa.Integer(), nullable=False),
+        sa.Column("question", sa.Text(), nullable=False),
+        sa.Column("selected_source_ids", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column("counterevidence_target", sa.Text(), nullable=False),
+        sa.Column("request_budget", sa.Integer(), nullable=False),
+        sa.Column("time_budget_minutes", sa.Integer(), nullable=False),
+        sa.Column("cost_budget_cents", sa.Integer(), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(
+            ["boundary_id"], ["approved_collection_boundaries.id"], ondelete="RESTRICT"
+        ),
+        sa.ForeignKeyConstraint(["objective_id"], ["discovery_objectives.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("objective_id", "version", name="uq_plan_objective_version"),
+    )
+    op.create_table(
+        "plan_revisions",
+        sa.Column("id", sa.UUID(), nullable=False),
+        sa.Column("plan_id", sa.UUID(), nullable=False),
+        sa.Column("predecessor_plan_id", sa.UUID(), nullable=False),
+        sa.Column("reason", sa.Text(), nullable=False),
+        sa.Column("delta", postgresql.JSONB(astext_type=sa.Text()), nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(["plan_id"], ["acquisition_plans.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(
+            ["predecessor_plan_id"], ["acquisition_plans.id"], ondelete="RESTRICT"
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("plan_id", name="uq_plan_revision_plan"),
+    )
+    op.add_column(
+        "acquisition_missions",
+        sa.Column("acquisition_plan_id", sa.UUID(), nullable=True),
+    )
+    op.create_foreign_key(
+        "fk_mission_acquisition_plan",
+        "acquisition_missions",
+        "acquisition_plans",
+        ["acquisition_plan_id"],
+        ["id"],
+        ondelete="RESTRICT",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_mission_acquisition_plan", "acquisition_missions", type_="foreignkey")
+    op.drop_column("acquisition_missions", "acquisition_plan_id")
+    op.drop_table("plan_revisions")
+    op.drop_table("acquisition_plans")
diff --git a/packages/storage/migrations/versions/e8f9a0b1c234_add_external_signal_source_link.py b/packages/storage/migrations/versions/e8f9a0b1c234_add_external_signal_source_link.py
new file mode 100644
index 0000000..d01eae4
--- /dev/null
+++ b/packages/storage/migrations/versions/e8f9a0b1c234_add_external_signal_source_link.py
@@ -0,0 +1,30 @@
+"""link External Signals to their registered collection source
+
+Revision ID: e8f9a0b1c234
+Revises: f1e2d3c4b506
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "e8f9a0b1c234"
+down_revision: str | None = "f1e2d3c4b506"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("external_signals", sa.Column("source_id", sa.UUID(), nullable=True))
+    op.create_foreign_key(
+        "fk_external_signal_source",
+        "external_signals",
+        "sources",
+        ["source_id"],
+        ["id"],
+        ondelete="RESTRICT",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_external_signal_source", "external_signals", type_="foreignkey")
+    op.drop_column("external_signals", "source_id")
diff --git a/packages/storage/migrations/versions/f1e2d3c4b506_add_assessment_strength.py b/packages/storage/migrations/versions/f1e2d3c4b506_add_assessment_strength.py
new file mode 100644
index 0000000..7e4f3fe
--- /dev/null
+++ b/packages/storage/migrations/versions/f1e2d3c4b506_add_assessment_strength.py
@@ -0,0 +1,29 @@
+"""add assessed evidence strength to Discovery Assessments
+
+Revision ID: f1e2d3c4b506
+Revises: d6e7f8a9b012
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "f1e2d3c4b506"
+down_revision: str | None = "d6e7f8a9b012"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "discovery_assessments",
+        sa.Column(
+            "evidence_strength",
+            sa.String(length=16),
+            nullable=False,
+            server_default="unknown",
+        ),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("discovery_assessments", "evidence_strength")
diff --git a/packages/storage/migrations/versions/f7a8b9c0d123_add_discovery_assessments_and_hypotheses.py b/packages/storage/migrations/versions/f7a8b9c0d123_add_discovery_assessments_and_hypotheses.py
new file mode 100644
index 0000000..b7b8d68
--- /dev/null
+++ b/packages/storage/migrations/versions/f7a8b9c0d123_add_discovery_assessments_and_hypotheses.py
@@ -0,0 +1,69 @@
+"""add discovery assessments and need hypotheses
+
+Revision ID: f7a8b9c0d123
+Revises: e6f7a8b9c012
+"""
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+revision: str = "f7a8b9c0d123"
+down_revision: str | None = "e6f7a8b9c012"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "discovery_assessments",
+        sa.Column("id", sa.UUID(), primary_key=True),
+        sa.Column("objective_id", sa.UUID(), nullable=False),
+        sa.Column("version", sa.Integer(), nullable=False),
+        sa.Column("kind", sa.String(length=32), nullable=False),
+        sa.Column("statement", sa.Text(), nullable=False),
+        sa.Column("evidence_ids", postgresql.JSONB(), nullable=False),
+        sa.Column("assessment_ids", postgresql.JSONB(), nullable=False),
+        sa.Column("unknowns", postgresql.JSONB(), nullable=False),
+        sa.Column("coverage_gaps", postgresql.JSONB(), nullable=False),
+        sa.Column("recommendation", sa.Text()),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(["objective_id"], ["discovery_objectives.id"], ondelete="CASCADE"),
+        sa.UniqueConstraint("objective_id", "version", name="uq_assessment_objective_version"),
+    )
+    op.create_table(
+        "need_hypotheses",
+        sa.Column("id", sa.UUID(), primary_key=True),
+        sa.Column("objective_id", sa.UUID(), nullable=False),
+        sa.Column("support_assessment_ids", postgresql.JSONB(), nullable=False),
+        sa.Column("title", sa.String(length=255), nullable=False),
+        sa.Column("target_actor", sa.Text(), nullable=False),
+        sa.Column("context", sa.Text(), nullable=False),
+        sa.Column("problem", sa.Text(), nullable=False),
+        sa.Column("desired_outcome", sa.Text(), nullable=False),
+        sa.Column("workaround", sa.Text()),
+        sa.Column("unknowns", postgresql.JSONB(), nullable=False),
+        sa.Column("next_validation_action", sa.Text(), nullable=False),
+        sa.Column("status", sa.String(length=16), server_default="draft", nullable=False),
+        sa.Column("promoted_need_issue_id", sa.UUID()),
+        sa.Column(
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.text("now()"),
+            nullable=False,
+        ),
+        sa.ForeignKeyConstraint(["objective_id"], ["discovery_objectives.id"], ondelete="CASCADE"),
+        sa.ForeignKeyConstraint(
+            ["promoted_need_issue_id"], ["need_issues.id"], ondelete="RESTRICT"
+        ),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("need_hypotheses")
+    op.drop_table("discovery_assessments")
diff --git a/packages/storage/models/__init__.py b/packages/storage/models/__init__.py
index af22c7e..b581daf 100644
--- a/packages/storage/models/__init__.py
+++ b/packages/storage/models/__init__.py
@@ -1,9 +1,18 @@
 from .acquisition_mission import AcquisitionMission
 from .acquisition_mission_run import AcquisitionMissionRun
 from .acquisition_mission_run_signal import AcquisitionMissionRunSignal
+from .acquisition_plan import AcquisitionPlan, PlanRevision
 from .agent_run import AgentRun
 from .comment import Comment
 from .content_version import ContentVersion
+from .discovery_assessment import DiscoveryAssessment, NeedHypothesis
+from .discovery_decision import DiscoveryDecisionRecord, OutcomeFeedback
+from .discovery_objective import (
+    ApprovedCollectionBoundary,
+    DiscoveryObjective,
+    OperatorApproval,
+    OperatorBoundaryRevision,
+)
 from .external_signal import ExternalSignal, SignalTriageEvent
 from .fetch_job import FetchJob
 from .media_asset import MediaAsset
@@ -39,11 +48,21 @@
     "SourceConfigProposal",
     "SourceProbeRun",
     "AcquisitionMission",
+    "AcquisitionPlan",
+    "PlanRevision",
     "AcquisitionMissionRun",
     "AcquisitionMissionRunSignal",
     "AgentRun",
     "SourceItem",
     "ContentVersion",
+    "DiscoveryObjective",
+    "ApprovedCollectionBoundary",
+    "OperatorApproval",
+    "OperatorBoundaryRevision",
+    "DiscoveryAssessment",
+    "NeedHypothesis",
+    "DiscoveryDecisionRecord",
+    "OutcomeFeedback",
     "ExternalSignal",
     "FetchJob",
     "Comment",
diff --git a/packages/storage/models/acquisition_mission.py b/packages/storage/models/acquisition_mission.py
index 2ddb387..c739103 100644
--- a/packages/storage/models/acquisition_mission.py
+++ b/packages/storage/models/acquisition_mission.py
@@ -48,6 +48,11 @@ class AcquisitionMission(Base):
         UUID(as_uuid=True),
         nullable=True,
     )
+    acquisition_plan_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("acquisition_plans.id", ondelete="RESTRICT"),
+        nullable=True,
+    )
     reality_question: Mapped[str] = mapped_column(Text, nullable=False)
     mission_type: Mapped[str] = mapped_column(String(32), nullable=False)
     regions: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
@@ -67,3 +72,4 @@ class AcquisitionMission(Base):
     )
 
     source_config_version = relationship("SourceConfigVersion", lazy="raise")
+    acquisition_plan = relationship("AcquisitionPlan", back_populates="missions", lazy="raise")
diff --git a/packages/storage/models/acquisition_plan.py b/packages/storage/models/acquisition_plan.py
new file mode 100644
index 0000000..28670c1
--- /dev/null
+++ b/packages/storage/models/acquisition_plan.py
@@ -0,0 +1,69 @@
+"""Versioned collection plans owned by Discovery Objectives."""
+
+import uuid
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import DateTime, ForeignKey, Integer, Text, UniqueConstraint, func
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from ..database import Base
+
+if TYPE_CHECKING:
+    from .acquisition_mission import AcquisitionMission
+
+
+class AcquisitionPlan(Base):
+    __tablename__ = "acquisition_plans"
+    __table_args__ = (
+        UniqueConstraint("objective_id", "version", name="uq_plan_objective_version"),
+    )
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    objective_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("discovery_objectives.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    boundary_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("approved_collection_boundaries.id", ondelete="RESTRICT"),
+        nullable=False,
+    )
+    version: Mapped[int] = mapped_column(Integer, nullable=False)
+    question: Mapped[str] = mapped_column(Text, nullable=False)
+    selected_source_ids: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    counterevidence_target: Mapped[str] = mapped_column(Text, nullable=False)
+    request_budget: Mapped[int] = mapped_column(Integer, nullable=False)
+    time_budget_minutes: Mapped[int] = mapped_column(Integer, nullable=False)
+    cost_budget_cents: Mapped[int] = mapped_column(Integer, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+
+    missions: Mapped[list["AcquisitionMission"]] = relationship(
+        back_populates="acquisition_plan", lazy="raise"
+    )
+
+
+class PlanRevision(Base):
+    __tablename__ = "plan_revisions"
+    __table_args__ = (UniqueConstraint("plan_id", name="uq_plan_revision_plan"),)
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    plan_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("acquisition_plans.id", ondelete="CASCADE"), nullable=False
+    )
+    predecessor_plan_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("acquisition_plans.id", ondelete="RESTRICT"), nullable=False
+    )
+    reason: Mapped[str] = mapped_column(Text, nullable=False)
+    delta: Mapped[dict] = mapped_column(JSONB, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+
+    plan: Mapped[AcquisitionPlan] = relationship(
+        foreign_keys=[plan_id], lazy="raise", uselist=False
+    )
diff --git a/packages/storage/models/agent_run.py b/packages/storage/models/agent_run.py
index cfe856d..2e0624e 100644
--- a/packages/storage/models/agent_run.py
+++ b/packages/storage/models/agent_run.py
@@ -3,7 +3,7 @@
 import uuid
 from datetime import datetime
 
-from sqlalchemy import DateTime, String, Text, UniqueConstraint, func
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, UniqueConstraint, func
 from sqlalchemy.dialects.postgresql import JSONB, UUID
 from sqlalchemy.orm import Mapped, mapped_column
 
@@ -16,6 +16,23 @@ class AgentRun(Base):
 
     id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     idempotency_key: Mapped[str] = mapped_column(String(255), nullable=False)
+    objective_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("discovery_objectives.id", ondelete="RESTRICT"),
+        nullable=True,
+    )
+    boundary_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("approved_collection_boundaries.id", ondelete="RESTRICT"),
+        nullable=True,
+    )
+    boundary_version: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    acquisition_plan_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("acquisition_plans.id", ondelete="RESTRICT"),
+        nullable=True,
+    )
+    input_context: Mapped[dict | None] = mapped_column(JSONB, nullable=True)
     task_instruction: Mapped[str] = mapped_column(Text, nullable=False)
     evidence_bundle: Mapped[list[dict]] = mapped_column(JSONB, nullable=False)
     evidence_bundle_hash: Mapped[str] = mapped_column(String(64), nullable=False)
diff --git a/packages/storage/models/discovery_assessment.py b/packages/storage/models/discovery_assessment.py
new file mode 100644
index 0000000..1ecd563
--- /dev/null
+++ b/packages/storage/models/discovery_assessment.py
@@ -0,0 +1,65 @@
+"""Evidence-cited judgements and operator-promotable Need Hypotheses."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, UniqueConstraint, func
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import Mapped, mapped_column
+
+from ..database import Base
+
+
+class DiscoveryAssessment(Base):
+    __tablename__ = "discovery_assessments"
+    __table_args__ = (
+        UniqueConstraint("objective_id", "version", name="uq_assessment_objective_version"),
+    )
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    objective_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("discovery_objectives.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    version: Mapped[int] = mapped_column(Integer, nullable=False)
+    kind: Mapped[str] = mapped_column(String(32), nullable=False)
+    statement: Mapped[str] = mapped_column(Text, nullable=False)
+    evidence_ids: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    assessment_ids: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    unknowns: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    coverage_gaps: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    recommendation: Mapped[str | None] = mapped_column(Text, nullable=True)
+    evidence_strength: Mapped[str] = mapped_column(
+        String(16), nullable=False, default="unknown", server_default="unknown"
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+
+
+class NeedHypothesis(Base):
+    __tablename__ = "need_hypotheses"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    objective_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("discovery_objectives.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    support_assessment_ids: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    title: Mapped[str] = mapped_column(String(255), nullable=False)
+    target_actor: Mapped[str] = mapped_column(Text, nullable=False)
+    context: Mapped[str] = mapped_column(Text, nullable=False)
+    problem: Mapped[str] = mapped_column(Text, nullable=False)
+    desired_outcome: Mapped[str] = mapped_column(Text, nullable=False)
+    workaround: Mapped[str | None] = mapped_column(Text, nullable=True)
+    unknowns: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    next_validation_action: Mapped[str] = mapped_column(Text, nullable=False)
+    status: Mapped[str] = mapped_column(String(16), nullable=False, default="draft")
+    promoted_need_issue_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("need_issues.id", ondelete="RESTRICT"), nullable=True
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
diff --git a/packages/storage/models/discovery_decision.py b/packages/storage/models/discovery_decision.py
new file mode 100644
index 0000000..0bbea52
--- /dev/null
+++ b/packages/storage/models/discovery_decision.py
@@ -0,0 +1,35 @@
+import uuid
+from datetime import datetime
+
+from sqlalchemy import DateTime, ForeignKey, String, Text, func
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import Mapped, mapped_column
+
+from ..database import Base
+
+
+class DiscoveryDecisionRecord(Base):
+    __tablename__ = "discovery_decision_records"
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    objective_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("discovery_objectives.id", ondelete="RESTRICT"), unique=True
+    )
+    decision: Mapped[str] = mapped_column(String(16))
+    reason: Mapped[str] = mapped_column(Text)
+    support_assessment_ids: Mapped[list[str]] = mapped_column(JSONB)
+    counter_assessment_ids: Mapped[list[str]] = mapped_column(JSONB)
+    unknowns: Mapped[list[str]] = mapped_column(JSONB)
+    resource_usage: Mapped[dict] = mapped_column(JSONB)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+
+
+class OutcomeFeedback(Base):
+    __tablename__ = "outcome_feedback"
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    decision_record_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("discovery_decision_records.id", ondelete="CASCADE")
+    )
+    kind: Mapped[str] = mapped_column(String(32))
+    reference: Mapped[str] = mapped_column(Text)
+    summary: Mapped[str] = mapped_column(Text)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
diff --git a/packages/storage/models/discovery_objective.py b/packages/storage/models/discovery_objective.py
new file mode 100644
index 0000000..a359d4a
--- /dev/null
+++ b/packages/storage/models/discovery_objective.py
@@ -0,0 +1,120 @@
+"""Durable operator-owned objective and its approved collection boundary."""
+
+import uuid
+from datetime import datetime
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, UniqueConstraint, func
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from ..database import Base
+
+
+class DiscoveryObjective(Base):
+    """One bounded question the Discovery Agent may investigate."""
+
+    __tablename__ = "discovery_objectives"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    title: Mapped[str] = mapped_column(String(200), nullable=False)
+    question: Mapped[str] = mapped_column(Text, nullable=False)
+    resource_stop_conditions: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    evidence_stop_conditions: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    decision_stop_conditions: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    status: Mapped[str] = mapped_column(String(24), nullable=False, default="active")
+    block_reason: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False
+    )
+
+    boundaries: Mapped[list["ApprovedCollectionBoundary"]] = relationship(
+        back_populates="objective",
+        cascade="all, delete-orphan",
+        order_by="ApprovedCollectionBoundary.version",
+        lazy="raise",
+    )
+
+
+class ApprovedCollectionBoundary(Base):
+    """An immutable, versioned limit on collection authority for an objective."""
+
+    __tablename__ = "approved_collection_boundaries"
+    __table_args__ = (
+        UniqueConstraint("objective_id", "version", name="uq_boundary_objective_version"),
+    )
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    objective_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("discovery_objectives.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    version: Mapped[int] = mapped_column(Integer, nullable=False)
+    approved_source_ids: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    tool_allowlist: Mapped[list[str]] = mapped_column(JSONB, nullable=False)
+    request_limit: Mapped[int] = mapped_column(Integer, nullable=False)
+    time_budget_minutes: Mapped[int] = mapped_column(Integer, nullable=False)
+    cost_budget_cents: Mapped[int] = mapped_column(Integer, nullable=False)
+    credential_scope: Mapped[list[str]] = mapped_column(JSONB, nullable=False, default=list)
+    evidence_conditions: Mapped[list[str]] = mapped_column(JSONB, nullable=False, default=list)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+
+    objective: Mapped[DiscoveryObjective] = relationship(back_populates="boundaries", lazy="raise")
+
+
+class OperatorApproval(Base):
+    """An auditable request to expand or alter collection authority."""
+
+    __tablename__ = "operator_approvals"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    objective_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("discovery_objectives.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    request_type: Mapped[str] = mapped_column(String(64), nullable=False)
+    reason: Mapped[str] = mapped_column(Text, nullable=False)
+    requested_boundary_patch: Mapped[dict] = mapped_column(JSONB, nullable=False)
+    status: Mapped[str] = mapped_column(String(16), nullable=False, default="pending")
+    operator: Mapped[str | None] = mapped_column(String(120), nullable=True)
+    decision_reason: Mapped[str | None] = mapped_column(Text, nullable=True)
+    decided_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+
+
+class OperatorBoundaryRevision(Base):
+    """A material, operator-authored change that creates the next boundary version."""
+
+    __tablename__ = "operator_boundary_revisions"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    objective_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("discovery_objectives.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    boundary_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("approved_collection_boundaries.id", ondelete="RESTRICT"),
+        nullable=False,
+    )
+    approval_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("operator_approvals.id", ondelete="RESTRICT"),
+        nullable=True,
+        unique=True,
+    )
+    operator: Mapped[str] = mapped_column(String(120), nullable=False)
+    reason: Mapped[str] = mapped_column(Text, nullable=False)
+    boundary_patch: Mapped[dict] = mapped_column(JSONB, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
diff --git a/packages/storage/models/external_signal.py b/packages/storage/models/external_signal.py
index 25913b1..3087d53 100644
--- a/packages/storage/models/external_signal.py
+++ b/packages/storage/models/external_signal.py
@@ -20,6 +20,9 @@ class ExternalSignal(Base):
         ForeignKey("acquisition_mission_runs.id", ondelete="RESTRICT"),
         nullable=True,
     )
+    source_id: Mapped[uuid.UUID | None] = mapped_column(
+        UUID(as_uuid=True), ForeignKey("sources.id", ondelete="RESTRICT"), nullable=True
+    )
     lineage_key: Mapped[str | None] = mapped_column(Text, nullable=True)
     raw_artifact_key: Mapped[str | None] = mapped_column(Text, nullable=True)
     source_label: Mapped[str] = mapped_column(Text, nullable=False)
diff --git a/tests/api/test_acquisition_plans.py b/tests/api/test_acquisition_plans.py
new file mode 100644
index 0000000..71c0aae
--- /dev/null
+++ b/tests/api/test_acquisition_plans.py
@@ -0,0 +1,164 @@
+"""Plans must stay inside their Objective's approved collection boundary."""
+
+from tests.api.test_acquisition_missions import _create_source_config, _mission_payload
+from tests.api.test_discovery_objectives import objective_payload
+from tests.factories import create_source
+
+
+async def create_objective(client, source_id):
+    response = await client.post("/api/discovery-objectives", json=objective_payload(source_id))
+    assert response.status_code == 201
+    return response.json()
+
+
+async def test_plan_pins_current_boundary_and_can_expose_its_mission_chain(client, db):
+    source = await create_source(db)
+    objective = await create_objective(client, source.id)
+
+    plan = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/plans",
+        json={
+            "question": "Which recovery costs recur across independent operator reports?",
+            "selected_source_ids": [str(source.id)],
+            "counterevidence_target": "Reports that the existing workaround is sufficient.",
+            "request_budget": 8,
+            "time_budget_minutes": 20,
+            "cost_budget_cents": 0,
+        },
+    )
+    workspace = await client.get(f"/api/discovery-objectives/{objective['id']}/workspace")
+
+    assert plan.status_code == 201
+    assert plan.json()["version"] == 1
+    assert plan.json()["boundary_version"] == 1
+    assert workspace.json()["plans"][0]["id"] == plan.json()["id"]
+    assert workspace.json()["plans"][0]["missions"] == []
+
+
+async def test_plan_rejects_sources_or_budgets_outside_current_boundary(client, db):
+    source = await create_source(db)
+    outside_source = await create_source(db, name="Outside", url="https://example.com/outside.xml")
+    objective = await create_objective(client, source.id)
+
+    rejected = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/plans",
+        json={
+            "question": "Can this source answer the objective?",
+            "selected_source_ids": [str(outside_source.id)],
+            "counterevidence_target": "A contrary observation.",
+            "request_budget": 13,
+            "time_budget_minutes": 20,
+            "cost_budget_cents": 0,
+        },
+    )
+
+    assert rejected.status_code == 422
+    assert "boundary" in rejected.json()["detail"].lower()
+
+
+async def test_plan_revision_retains_predecessor_and_reason(client, db):
+    source = await create_source(db)
+    objective = await create_objective(client, source.id)
+    initial = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/plans",
+        json={
+            "question": "What recovery costs recur?",
+            "selected_source_ids": [str(source.id)],
+            "counterevidence_target": "No recurring recovery cost.",
+            "request_budget": 4,
+            "time_budget_minutes": 10,
+            "cost_budget_cents": 0,
+        },
+    )
+
+    revised = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/plans",
+        json={
+            "question": "What recovery costs recur across distinct threads?",
+            "selected_source_ids": [str(source.id)],
+            "counterevidence_target": "A workaround removes the cost.",
+            "request_budget": 6,
+            "time_budget_minutes": 15,
+            "cost_budget_cents": 0,
+            "predecessor_plan_id": initial.json()["id"],
+            "revision_reason": "Coverage gap: the first plan had only one thread.",
+            "revision_delta": {"source_independence_required": True},
+        },
+    )
+
+    assert revised.status_code == 201
+    assert revised.json()["version"] == 2
+    assert revised.json()["predecessor_plan_id"] == initial.json()["id"]
+    assert revised.json()["revision"]["reason"] == (
+        "Coverage gap: the first plan had only one thread."
+    )
+
+
+async def test_linked_mission_must_keep_using_a_plan_allowed_by_current_boundary(client, db):
+    source = await create_source(db)
+    objective = await create_objective(client, source.id)
+    plan = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/plans",
+        json={
+            "question": "What recurring recovery costs appear?",
+            "selected_source_ids": [str(source.id)],
+            "counterevidence_target": "No recurring cost appears.",
+            "request_budget": 8,
+            "time_budget_minutes": 20,
+            "cost_budget_cents": 0,
+        },
+    )
+    config = await _create_source_config(client, source.id)
+
+    linked = await client.post(
+        "/api/acquisition-missions",
+        json=_mission_payload(
+            source.id,
+            config["id"],
+            acquisition_plan_id=plan.json()["id"],
+            cost_budget_cents=0,
+        ),
+    )
+    queued = await client.post(
+        f"/api/acquisition-missions/{linked.json()['id']}/queued-runs",
+        json={"execution_mode": "fixture"},
+    )
+    workspace = await client.get(f"/api/discovery-objectives/{objective['id']}/workspace")
+    approval = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/approvals",
+        json={
+            "request_type": "budget_change",
+            "reason": "A small additional allowance is required.",
+            "requested_boundary_patch": {"request_limit": 16},
+        },
+    )
+    await client.post(
+        f"/api/discovery-objectives/{objective['id']}/approvals/{approval.json()['id']}/approve",
+        json={"operator": "owner", "reason": "Approved."},
+    )
+    stale = await client.post(
+        "/api/acquisition-missions",
+        json=_mission_payload(
+            source.id,
+            config["id"],
+            acquisition_plan_id=plan.json()["id"],
+            cost_budget_cents=0,
+        ),
+    )
+    stale_run = await client.post(
+        f"/api/acquisition-missions/{linked.json()['id']}/queued-runs",
+        json={"execution_mode": "fixture"},
+    )
+
+    assert linked.status_code == 201
+    assert queued.status_code == 201
+    assert linked.json()["acquisition_plan_id"] == plan.json()["id"]
+    assert (
+        workspace.json()["plans"][0]["mission_runs"][linked.json()["id"]][0]["id"]
+        == queued.json()["id"]
+    )
+    assert stale.status_code == 409
+    assert stale_run.status_code == 409
+    assert (
+        stale_run.json()["detail"] == "Plan is no longer permitted by the current approved boundary"
+    )
diff --git a/tests/api/test_discovery_agent_runs.py b/tests/api/test_discovery_agent_runs.py
new file mode 100644
index 0000000..d655e4d
--- /dev/null
+++ b/tests/api/test_discovery_agent_runs.py
@@ -0,0 +1,258 @@
+"""Objective-scoped Pi runs cannot exceed the active collection boundary."""
+
+from datetime import UTC, datetime
+
+from tests.api.test_discovery_objectives import objective_payload
+from tests.factories import create_source
+
+
+async def test_objective_agent_run_pins_boundary_and_rejects_blocked_objective(client, db):
+    source = await create_source(db)
+    objective = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    signal = await client.post(
+        "/api/external-signals",
+        json={
+            "source_id": str(source.id),
+            "source_label": "Public discussion",
+            "original_material": "I reconcile reports each Friday.",
+            "observed_at": datetime.now(UTC).isoformat(),
+            "observation": "A manual workaround is reported.",
+        },
+    )
+    payload = {
+        "evidence_signal_ids": [signal.json()["id"]],
+        "task_instruction": "Return a structured assessment proposal only.",
+        "idempotency_key": "objective-agent-run-v1",
+        "model_version": "pi-faux-v1",
+        "prompt_version": "discovery-assessment-v1",
+        "max_tool_calls": 2,
+        "max_tokens": 500,
+        "max_cost_cents": 0,
+    }
+
+    created = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/agent-runs", json=payload
+    )
+    await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/block",
+        json={"reason": "No approved next action remains."},
+    )
+    rejected = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/agent-runs",
+        json={**payload, "idempotency_key": "blocked-run"},
+    )
+
+    assert created.status_code == 201
+    assert created.json()["objective_id"] == objective.json()["id"]
+    assert created.json()["boundary_version"] == 1
+    assert created.json()["tool_allowlist"] == ["github_issue_collection"]
+    assert created.json()["input_context"]["objective"]["status"] == "active"
+    assert created.json()["input_context"]["boundary"]["version"] == 1
+    assert rejected.status_code == 409
+
+
+async def test_objective_agent_run_is_rejected_at_execution_when_boundary_is_no_longer_active(
+    client, db
+):
+    source = await create_source(db)
+    objective = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    signal = await client.post(
+        "/api/external-signals",
+        json={
+            "source_id": str(source.id),
+            "source_label": "Public discussion",
+            "original_material": "I reconcile reports each Friday.",
+            "observed_at": datetime.now(UTC).isoformat(),
+            "observation": "A manual workaround is reported.",
+        },
+    )
+    run = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/agent-runs",
+        json={
+            "evidence_signal_ids": [signal.json()["id"]],
+            "task_instruction": "Return a structured assessment proposal only.",
+            "idempotency_key": "objective-agent-run-execute-v1",
+            "model_version": "pi-faux-v1",
+            "prompt_version": "discovery-assessment-v1",
+            "max_tool_calls": 1,
+            "max_tokens": 500,
+            "max_cost_cents": 0,
+        },
+    )
+    await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/block",
+        json={"reason": "No approved next action remains."},
+    )
+
+    execution = await client.post(f"/api/agent-runs/{run.json()['id']}/execute")
+
+    assert execution.status_code == 409
+    assert execution.json()["detail"] == "Discovery Agent run boundary is no longer active"
+
+
+async def test_objective_agent_run_returns_a_structured_assessment_proposal(client, db):
+    source = await create_source(db)
+    objective = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    signal = await client.post(
+        "/api/external-signals",
+        json={
+            "source_id": str(source.id),
+            "source_label": "Public discussion",
+            "original_material": "I reconcile reports each Friday.",
+            "observed_at": datetime.now(UTC).isoformat(),
+            "observation": "A manual workaround is reported.",
+        },
+    )
+    run = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/agent-runs",
+        json={
+            "evidence_signal_ids": [signal.json()["id"]],
+            "task_instruction": "Return a structured assessment proposal only.",
+            "idempotency_key": "objective-agent-run-proposal-v1",
+            "model_version": "pi-faux-v1",
+            "prompt_version": "discovery-assessment-v1",
+            "max_tool_calls": 1,
+            "max_tokens": 500,
+            "max_cost_cents": 0,
+        },
+    )
+
+    completed = await client.post(f"/api/agent-runs/{run.json()['id']}/execute")
+
+    assert completed.status_code == 200
+    proposal = completed.json()["output"]["proposal"]
+    assert proposal["contract"] == "discovery_assessment_proposal.v1"
+    assert proposal["kind"] == "unknown"
+    assert proposal["evidence_ids"] == [signal.json()["id"]]
+
+
+async def test_plan_bound_agent_run_can_only_return_a_structured_revision_proposal(client, db):
+    source = await create_source(db)
+    objective = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    plan = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/plans",
+        json={
+            "question": "Which reconciliation costs recur?",
+            "selected_source_ids": [str(source.id)],
+            "counterevidence_target": "A sufficient existing workaround.",
+            "request_budget": 1,
+            "time_budget_minutes": 5,
+            "cost_budget_cents": 0,
+        },
+    )
+    signal = await client.post(
+        "/api/external-signals",
+        json={
+            "source_id": str(source.id),
+            "source_label": "Public discussion",
+            "original_material": "I reconcile reports each Friday.",
+            "observed_at": datetime.now(UTC).isoformat(),
+            "observation": "A manual workaround is reported.",
+        },
+    )
+    run = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/agent-runs",
+        json={
+            "evidence_signal_ids": [signal.json()["id"]],
+            "task_instruction": "Propose a plan revision only.",
+            "idempotency_key": "objective-agent-plan-revision-v1",
+            "model_version": "pi-faux-v1",
+            "prompt_version": "discovery-plan-revision-v1",
+            "max_tool_calls": 1,
+            "max_tokens": 1_000,
+            "max_cost_cents": 0,
+            "max_time_minutes": 5,
+            "acquisition_plan_id": plan.json()["id"],
+            "proposal_type": "plan_revision",
+        },
+    )
+
+    completed = await client.post(f"/api/agent-runs/{run.json()['id']}/execute")
+
+    assert run.status_code == 201
+    assert run.json()["acquisition_plan_id"] == plan.json()["id"]
+    assert run.json()["input_context"]["plan"]["id"] == plan.json()["id"]
+    assert completed.status_code == 200
+    assert completed.json()["status"] == "completed", completed.json()["errors"]
+    assert completed.json()["output"]["proposal"] == {
+        "contract": "acquisition_plan_revision_proposal.v1",
+        "predecessor_plan_id": plan.json()["id"],
+        "proposed_delta": {},
+        "reason": "Pi output cannot support a Plan Revision proposal yet.",
+        "coverage_gaps": ["Pi output did not satisfy the plan revision contract."],
+        "status": "unknown",
+    }
+
+
+async def test_agent_run_idempotency_key_cannot_cross_discovery_objective_boundary(client, db):
+    source = await create_source(db)
+    first = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    second = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    signal = await client.post(
+        "/api/external-signals",
+        json={
+            "source_id": str(source.id),
+            "source_label": "Public discussion",
+            "original_material": "I reconcile reports each Friday.",
+            "observed_at": datetime.now(UTC).isoformat(),
+            "observation": "A manual workaround is reported.",
+        },
+    )
+    payload = {
+        "evidence_signal_ids": [signal.json()["id"]],
+        "task_instruction": "Return a structured assessment proposal only.",
+        "idempotency_key": "shared-key-across-objectives",
+        "model_version": "pi-faux-v1",
+        "prompt_version": "discovery-assessment-v1",
+        "max_tool_calls": 1,
+        "max_tokens": 500,
+        "max_cost_cents": 0,
+    }
+    created = await client.post(
+        f"/api/discovery-objectives/{first.json()['id']}/agent-runs", json=payload
+    )
+    conflict = await client.post(
+        f"/api/discovery-objectives/{second.json()['id']}/agent-runs", json=payload
+    )
+
+    assert created.status_code == 201
+    assert conflict.status_code == 409
+    assert conflict.json()["detail"] == "Agent Run idempotency key belongs to another Objective"
+
+
+async def test_objective_agent_run_rejects_evidence_outside_approved_source_boundary(client, db):
+    approved_source = await create_source(db)
+    unapproved_source = await create_source(db)
+    objective = await client.post(
+        "/api/discovery-objectives", json=objective_payload(approved_source.id)
+    )
+    signal = await client.post(
+        "/api/external-signals",
+        json={
+            "source_id": str(unapproved_source.id),
+            "source_label": "Other public discussion",
+            "original_material": "This source is not approved for this objective.",
+            "observed_at": datetime.now(UTC).isoformat(),
+            "observation": "An out-of-bound observation is reported.",
+        },
+    )
+
+    rejected = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/agent-runs",
+        json={
+            "evidence_signal_ids": [signal.json()["id"]],
+            "task_instruction": "Return a structured assessment proposal only.",
+            "idempotency_key": "out-of-bound-evidence",
+            "model_version": "pi-faux-v1",
+            "prompt_version": "discovery-assessment-v1",
+            "max_tool_calls": 1,
+            "max_tokens": 500,
+            "max_cost_cents": 0,
+        },
+    )
+
+    assert signal.status_code == 201
+    assert rejected.status_code == 422
+    assert rejected.json()["detail"] == (
+        "Every evidence signal must belong to the current approved boundary"
+    )
diff --git a/tests/api/test_discovery_assessments.py b/tests/api/test_discovery_assessments.py
new file mode 100644
index 0000000..a195518
--- /dev/null
+++ b/tests/api/test_discovery_assessments.py
@@ -0,0 +1,153 @@
+"""Evidence-cited assessments and operator-promoted Need Hypotheses."""
+
+from datetime import UTC, datetime
+
+from tests.api.test_discovery_objectives import objective_payload
+from tests.factories import create_source
+
+
+async def _objective(client, db):
+    source = await create_source(db)
+    created = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    return created.json()
+
+
+async def _accepted_signal(client):
+    signal = await client.post(
+        "/api/external-signals",
+        json={
+            "source_label": "Public discussion",
+            "source_uri": "https://example.com/discussion/42",
+            "original_material": "I reconcile reports manually each Friday.",
+            "observed_at": datetime.now(UTC).isoformat(),
+            "observation": "A repeated manual reconciliation workaround is described.",
+        },
+    )
+    await client.post(
+        f"/api/external-signals/{signal.json()['id']}/triage",
+        json={"status": "accepted", "reason": "Original context supports review."},
+    )
+    return signal.json()
+
+
+async def test_assessment_requires_citations_and_workspace_exposes_its_judgement(client, db):
+    objective = await _objective(client, db)
+    signal = await _accepted_signal(client)
+
+    rejected = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/assessments",
+        json={"kind": "support", "statement": "A claim without evidence.", "evidence_ids": []},
+    )
+    created = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/assessments",
+        json={
+            "kind": "support",
+            "statement": "The operator reports a repeated manual workaround.",
+            "evidence_ids": [signal["id"]],
+            "unknowns": ["How common this is across independent operators"],
+            "recommendation": "Seek counterevidence from an automated workflow.",
+            "evidence_strength": "moderate",
+        },
+    )
+    workspace = await client.get(f"/api/discovery-objectives/{objective['id']}/workspace")
+
+    assert rejected.status_code == 422
+    assert created.status_code == 201
+    assert created.json()["version"] == 1
+    assert created.json()["evidence_strength"] == "moderate"
+    assert workspace.json()["assessments"][0]["evidence_ids"] == [signal["id"]]
+
+
+async def test_need_hypothesis_rejects_uncited_or_non_supporting_assessments(client, db):
+    objective = await _objective(client, db)
+    signal = await _accepted_signal(client)
+    counter = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/assessments",
+        json={
+            "kind": "counterevidence",
+            "statement": "One alternative works.",
+            "evidence_ids": [signal["id"]],
+        },
+    )
+
+    rejected = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/need-hypotheses",
+        json={
+            "title": "Manual reconciliation cost",
+            "target_actor": "operators",
+            "context": "weekly reporting",
+            "problem": "manual reconciliation consumes time",
+            "desired_outcome": "reconcile without repeated manual work",
+            "next_validation_action": "find another independent operator",
+            "support_assessment_ids": [counter.json()["id"]],
+        },
+    )
+
+    assert rejected.status_code == 422
+    assert "support" in rejected.json()["detail"].lower()
+
+
+async def test_assessment_rejects_upstream_citation_outside_its_objective(client, db):
+    first = await _objective(client, db)
+    second = await _objective(client, db)
+    signal = await _accepted_signal(client)
+    upstream = await client.post(
+        f"/api/discovery-objectives/{first['id']}/assessments",
+        json={
+            "kind": "support",
+            "statement": "An observed workaround exists.",
+            "evidence_ids": [signal["id"]],
+        },
+    )
+    response = await client.post(
+        f"/api/discovery-objectives/{second['id']}/assessments",
+        json={
+            "kind": "support",
+            "statement": "This must not cite another Objective's assessment.",
+            "assessment_ids": [upstream.json()["id"]],
+        },
+    )
+
+    assert response.status_code == 422
+    assert (
+        response.json()["detail"]
+        == "Assessment cites an upstream Assessment outside this Objective"
+    )
+
+
+async def test_operator_can_explicitly_promote_supported_hypothesis_without_auto_creation(
+    client, db
+):
+    objective = await _objective(client, db)
+    signal = await _accepted_signal(client)
+    support = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/assessments",
+        json={
+            "kind": "support",
+            "statement": "A repeated cost is described.",
+            "evidence_ids": [signal["id"]],
+        },
+    )
+    hypothesis = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/need-hypotheses",
+        json={
+            "title": "Manual reconciliation cost",
+            "target_actor": "operators",
+            "context": "weekly reporting",
+            "problem": "manual reconciliation consumes time",
+            "desired_outcome": "reconcile without repeated manual work",
+            "next_validation_action": "find another independent operator",
+            "support_assessment_ids": [support.json()["id"]],
+        },
+    )
+    before = await client.get("/api/need-issues")
+    promoted = await client.post(
+        f"/api/discovery-objectives/{objective['id']}/need-hypotheses/{hypothesis.json()['id']}/promote",
+        json={"operator": "owner"},
+    )
+
+    assert before.json()["total"] == 0
+    assert hypothesis.status_code == 201
+    assert hypothesis.json()["status"] == "draft"
+    assert promoted.status_code == 201
+    assert promoted.json()["status"] == "captured"
diff --git a/tests/api/test_discovery_decision_records.py b/tests/api/test_discovery_decision_records.py
new file mode 100644
index 0000000..30e7f43
--- /dev/null
+++ b/tests/api/test_discovery_decision_records.py
@@ -0,0 +1,70 @@
+"""Closing an Objective creates an immutable decision record with append-only outcomes."""
+
+from tests.api.test_discovery_objectives import objective_payload
+from tests.factories import create_source
+
+
+async def test_close_objective_creates_decision_record_and_appends_outcome_feedback(client, db):
+    source = await create_source(db)
+    objective = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    record = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/decision-records",
+        json={
+            "decision": "abandoned",
+            "reason": "Counterevidence outweighs the available support.",
+            "support_assessment_ids": [],
+            "counter_assessment_ids": [],
+            "unknowns": ["Whether a narrower segment experiences the cost"],
+            "resource_usage": {"requests": 12, "minutes": 30, "cost_cents": 0},
+        },
+    )
+    outcome = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/decision-records/{record.json()['id']}/outcomes",
+        json={
+            "kind": "support",
+            "reference": "tracking://product/42",
+            "summary": "Later tracking is calibration input only.",
+        },
+    )
+
+    assert record.status_code == 201
+    assert record.json()["decision"] == "abandoned"
+    assert outcome.status_code == 201
+    assert outcome.json()["decision_record_id"] == record.json()["id"]
+
+    workspace = await client.get(f"/api/discovery-objectives/{objective.json()['id']}/workspace")
+
+    assert workspace.status_code == 200
+    assert workspace.json()["decision_record"]["reason"] == (
+        "Counterevidence outweighs the available support."
+    )
+    assert workspace.json()["decision_record"]["outcomes"] == [
+        {
+            "id": outcome.json()["id"],
+            "decision_record_id": record.json()["id"],
+            "kind": "support",
+            "reference": "tracking://product/42",
+            "summary": "Later tracking is calibration input only.",
+            "created_at": outcome.json()["created_at"],
+        }
+    ]
+
+
+async def test_decision_record_rejects_unknown_assessment_citations(client, db):
+    source = await create_source(db)
+    objective = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+
+    response = await client.post(
+        f"/api/discovery-objectives/{objective.json()['id']}/decision-records",
+        json={
+            "decision": "abandoned",
+            "reason": "The question cannot be supported yet.",
+            "support_assessment_ids": ["00000000-0000-0000-0000-000000000001"],
+            "counter_assessment_ids": [],
+            "unknowns": [],
+            "resource_usage": {"requests": 0, "minutes": 0, "cost_cents": 0},
+        },
+    )
+
+    assert response.status_code == 422
+    assert response.json()["detail"] == "Decision Record cites an assessment outside this objective"
diff --git a/tests/api/test_discovery_objectives.py b/tests/api/test_discovery_objectives.py
new file mode 100644
index 0000000..caafecb
--- /dev/null
+++ b/tests/api/test_discovery_objectives.py
@@ -0,0 +1,139 @@
+"""Public API contracts for the first Discovery Objective workspace."""
+
+import uuid
+
+from tests.factories import create_source
+
+
+def objective_payload(source_id: uuid.UUID) -> dict:
+    return {
+        "title": "Independent operator incident recovery",
+        "question": "What recurring recovery cost do independent operators describe?",
+        "resource_stop_conditions": ["No more than 12 requests"],
+        "evidence_stop_conditions": ["At least two independent sources"],
+        "decision_stop_conditions": ["Promote, rewrite, abandon, or block"],
+        "initial_boundary": {
+            "approved_source_ids": [str(source_id)],
+            "tool_allowlist": ["github_issue_collection"],
+            "request_limit": 12,
+            "time_budget_minutes": 30,
+            "cost_budget_cents": 0,
+        },
+    }
+
+
+async def test_create_objective_creates_an_immutable_initial_collection_boundary(client, db):
+    source = await create_source(db)
+
+    response = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+
+    assert response.status_code == 201
+    body = response.json()
+    assert body["status"] == "active"
+    assert body["question"] == "What recurring recovery cost do independent operators describe?"
+    assert body["current_boundary"]["version"] == 1
+    assert body["current_boundary"]["approved_source_ids"] == [str(source.id)]
+    assert body["current_boundary"]["request_limit"] == 12
+
+
+async def test_objective_workspace_returns_the_objective_and_its_current_boundary(client, db):
+    source = await create_source(db)
+    created = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+
+    response = await client.get(f"/api/discovery-objectives/{created.json()['id']}/workspace")
+
+    assert response.status_code == 200
+    body = response.json()
+    assert body["objective"]["id"] == created.json()["id"]
+    assert body["current_boundary"]["version"] == 1
+    assert body["plans"] == []
+    assert body["assessments"] == []
+
+
+async def test_objective_rejects_an_initial_boundary_that_names_an_unknown_source(client):
+    response = await client.post("/api/discovery-objectives", json=objective_payload(uuid.uuid4()))
+
+    assert response.status_code == 422
+    assert "approved source" in response.json()["detail"].lower()
+
+
+async def test_approval_request_pauses_objective_until_operator_decides(client, db):
+    source = await create_source(db)
+    created = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    objective_id = created.json()["id"]
+
+    approval = await client.post(
+        f"/api/discovery-objectives/{objective_id}/approvals",
+        json={
+            "request_type": "new_source",
+            "reason": "A second independent source is required to test repetition.",
+            "requested_boundary_patch": {"approved_source_ids": [str(source.id)]},
+        },
+    )
+    workspace = await client.get(f"/api/discovery-objectives/{objective_id}/workspace")
+
+    assert approval.status_code == 201
+    assert approval.json()["status"] == "pending"
+    assert workspace.json()["objective"]["status"] == "pending_approval"
+    assert workspace.json()["pending_approvals"][0]["id"] == approval.json()["id"]
+
+
+async def test_approving_request_versions_boundary_and_restores_active_objective(client, db):
+    source = await create_source(db)
+    second_source = await create_source(
+        db, name="Second Source", url="https://example.com/second.xml"
+    )
+    created = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    objective_id = created.json()["id"]
+    approval = await client.post(
+        f"/api/discovery-objectives/{objective_id}/approvals",
+        json={
+            "request_type": "new_source",
+            "reason": "A second independent source is required.",
+            "requested_boundary_patch": {"approved_source_ids": [str(second_source.id)]},
+        },
+    )
+
+    decided = await client.post(
+        f"/api/discovery-objectives/{objective_id}/approvals/{approval.json()['id']}/approve",
+        json={"operator": "owner", "reason": "Approve one independent public source."},
+    )
+    workspace = await client.get(f"/api/discovery-objectives/{objective_id}/workspace")
+
+    assert decided.status_code == 200
+    assert decided.json()["status"] == "approved"
+    assert workspace.json()["objective"]["status"] == "active"
+    assert workspace.json()["current_boundary"]["version"] == 2
+    assert workspace.json()["current_boundary"]["approved_source_ids"] == [str(second_source.id)]
+    assert workspace.json()["boundary_revisions"][0]["approval_id"] == approval.json()["id"]
+
+
+async def test_blocked_objective_can_only_reactivate_through_material_boundary_revision(client, db):
+    source = await create_source(db)
+    created = await client.post("/api/discovery-objectives", json=objective_payload(source.id))
+    objective_id = created.json()["id"]
+
+    blocked = await client.post(
+        f"/api/discovery-objectives/{objective_id}/block",
+        json={"reason": "The approved source is exhausted and cannot answer the question."},
+    )
+    no_change = await client.post(
+        f"/api/discovery-objectives/{objective_id}/boundary-revisions",
+        json={"operator": "owner", "reason": "Try again", "boundary_patch": {}},
+    )
+    revised = await client.post(
+        f"/api/discovery-objectives/{objective_id}/boundary-revisions",
+        json={
+            "operator": "owner",
+            "reason": "Grant a larger request budget for a new bounded pass.",
+            "boundary_patch": {"request_limit": 24},
+        },
+    )
+
+    assert blocked.status_code == 200
+    assert blocked.json()["status"] == "blocked"
+    assert no_change.status_code == 422
+    assert revised.status_code == 201
+    assert revised.json()["boundary_version"] == 2
+    objective = await client.get(f"/api/discovery-objectives/{objective_id}")
+    assert objective.json()["status"] == "active"
diff --git a/tests/web/test_discovery_objectives.py b/tests/web/test_discovery_objectives.py
new file mode 100644
index 0000000..ae263c0
--- /dev/null
+++ b/tests/web/test_discovery_objectives.py
@@ -0,0 +1,35 @@
+"""Public page contract for the Discovery Objective workspace."""
+
+
+async def test_objective_workspace_page_loads_the_durable_workspace_contract(client):
+    response = await client.get("/objectives/11111111-1111-1111-1111-111111111111")
+
+    assert response.status_code == 200
+    page = response.text
+    assert 'id="objective-workspace"' in page
+    assert 'id="objective-status"' in page
+    assert "/api/discovery-objectives/${objectiveId}/workspace" in page
+    assert "Approved collection boundary" in page
+    assert "pending_approvals" in page
+    assert "boundary_revisions" in page
+    assert "workspace.plans" in page
+    assert 'id="approval-actions"' in page
+    assert 'id="boundary-revision-form"' in page
+    assert "approveApproval" in page
+    assert 'id="decision-record-panel"' in page
+    assert 'id="mission-console-link" href="/missions"' in page
+    assert 'id="mission-console-region"' in page
+    assert 'src="/missions"' in page
+    assert 'id="strongest-counterevidence"' in page
+    assert 'id="assessment-unknowns"' in page
+    assert "plan.revision" in page
+    assert "assessment.evidence_ids" in page
+    assert "workspace.decision_record" in page
+    assert "校准下一次判断" in page
+    assert 'id="assessments-panel"' in page
+    assert 'id="agent-runs-panel"' in page
+    assert 'id="agent-proposals"' in page
+    assert "run.output?.proposal" in page
+    assert 'id="evidence-panel"' in page
+    assert 'id="approval-panel"' in page
+    assert 'id="decision-record-panel"' in page
diff --git a/tests/web/test_missions_workbench.py b/tests/web/test_missions_workbench.py
index afa0bda..3d88dcc 100644
--- a/tests/web/test_missions_workbench.py
+++ b/tests/web/test_missions_workbench.py
@@ -6,6 +6,11 @@ async def test_missions_workbench_exposes_an_explicit_bounded_mission_flow(clien
 
     assert response.status_code == 200
     page = response.text
+    assert 'class="app-sidebar"' in page
+    assert 'id="collection-layout"' in page
+    assert 'id="source-panel"' in page
+    assert 'id="mission-editor"' in page
+    assert 'id="operation-rail"' in page
     assert 'id="mission-form"' in page
     assert 'id="source-id"' in page
     assert 'id="source-config-form"' in page
@@ -42,17 +47,21 @@ async def test_missions_workbench_exposes_an_explicit_bounded_mission_flow(clien
     assert "Lease" in page
 
 
-async def test_dashboard_prioritizes_reality_action_and_objection_over_volume_metrics(client):
+async def test_dashboard_prioritizes_collection_workbench_over_validation_tasks(client):
     response = await client.get("/")
 
     assert response.status_code == 200
     page = response.text
-    assert 'id="today-workspace"' in page
-    assert "/api/today" in page
-    assert "Strongest objection" in page
-    assert "Next reality action" in page
-    assert "Record an observation" in page
-    assert "Plan a bounded mission" in page
+    assert 'id="collection-workbench"' in page
+    assert "Open collection workbench" in page
+    assert "Define a source" in page
+    assert "Review collected evidence" in page
+    assert "/missions" in page
+    assert "/sources/create" in page
+    assert "/api/evidence-inbox" in page
+    assert "/api/today" not in page
+    assert "Strongest objection" not in page
+    assert "Next reality action" not in page
     assert "Success Rate (24h)" not in page
     assert "Items Collected" not in page