okstra 0.143.0 → 0.145.0

package/runtime/python/okstra_ctl/render.py

@@ -29,6 +29,7 @@ from okstra_project.dirs import TASK_MANIFEST_FILENAME, OKSTRA_DIR_NAME, project
 # render_task_manifest 가 동일한 리스트/딕셔너리를 로컬에 중복 정의했는데,
 # 이는 silent drift 위험이 있어 SSOT import 로 통합한다.
 from . import fix_cycles
+from .analysis_inputs import ANALYSIS_TASK_TYPES
 from .paths import okstra_home
 from .lead_runtime import lead_runtime_info
 from .path_hints import compact_active_run_context, hydrate_run_context
@@ -874,6 +875,45 @@ def _required_worker_roles(ctx: dict, reviewers: list[str]) -> list[dict]:
     ]
 
 
+def _reporter_confirmation_status(brief_bytes: bytes) -> str:
+    try:
+        lines = brief_bytes.decode("utf-8").splitlines()
+    except UnicodeDecodeError:
+        return ""
+    if not lines or lines[0].strip() != "---":
+        return ""
+    for line in lines[1:]:
+        if line.strip() == "---":
+            break
+        key, separator, value = line.partition(":")
+        if separator and key.strip() == "reporter-confirmations":
+            return value.strip().strip("'\"").lower()
+    return ""
+
+
+def _analysis_scope_confirmation_snapshot(ctx: dict) -> dict | None:
+    if ctx.get("TASK_TYPE") not in ANALYSIS_TASK_TYPES:
+        return None
+    brief_path = Path(ctx.get("BRIEF_FILE_PATH", ""))
+    try:
+        brief_bytes = brief_path.read_bytes() if brief_path.is_file() else None
+    except OSError:
+        brief_bytes = None
+    return {
+        "taskBriefPath": ctx.get("BRIEF_RELATIVE_PATH", ""),
+        "status": (
+            _reporter_confirmation_status(brief_bytes)
+            if brief_bytes is not None
+            else ""
+        ),
+        "briefSha256": (
+            hashlib.sha256(brief_bytes).hexdigest()
+            if brief_bytes is not None
+            else ""
+        ),
+    }
+
+
 def _derive_phase_states(existing_workflow: dict, ctx: dict) -> tuple[dict, str, str]:
     """phaseStates dict + (current_phase, current_phase_state) 를 도출한다.
 
@@ -1204,9 +1244,8 @@ def _build_convergence_block(ctx: dict) -> dict:
     - `enabled` default True
     - `maxRounds` default 1 for `requirements-discovery`, 2 otherwise
     - `verificationMode` default "lightweight"
-    - `adversarial` default True for `requirements-discovery` / `error-analysis` /
-      `implementation-planning` (forces `verificationMode` to "full-reanalysis"),
-      False otherwise
+    - `adversarial` default True for discovery, planning, and analysis task types
+      (forces `verificationMode` to "full-reanalysis"), False otherwise
     - `planBodyVerification` is implementation-planning specific; the key is
       always emitted (dead-letter on other phases) so the schema stays stable.
       Its `selfFixMaxRounds` default 3 bounds the report-writer self-fix loop
@@ -1222,7 +1261,14 @@ def _build_convergence_block(ctx: dict) -> dict:
     """
     task_type = ctx.get("TASK_TYPE", "")
     default_max_rounds = 1 if task_type == "requirements-discovery" else 2
-    adversarial_phases = {"requirements-discovery", "error-analysis", "implementation-planning"}
+    adversarial_phases = {
+        "requirements-discovery",
+        "error-analysis",
+        "implementation-planning",
+        "project-analysis",
+        "feature-analysis",
+        "change-impact-analysis",
+    }
     is_adversarial = task_type in adversarial_phases
     raw_plan_verify = (ctx.get("OKSTRA_PLAN_VERIFICATION", "") or "").strip().lower()
     plan_verify_enabled = raw_plan_verify != "false"
@@ -1257,6 +1303,20 @@ def _build_convergence_block(ctx: dict) -> dict:
 
 
 def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
+    run_manifest_file = Path(run_manifest_path)
+    existing_run_manifest = {}
+    if run_manifest_file.is_file():
+        try:
+            loaded_run_manifest = json.loads(
+                run_manifest_file.read_text(encoding="utf-8")
+            )
+            existing_run_manifest = (
+                loaded_run_manifest
+                if isinstance(loaded_run_manifest, dict)
+                else {}
+            )
+        except (OSError, json.JSONDecodeError):
+            existing_run_manifest = {}
     task_manifest_path = Path(ctx.get("TASK_MANIFEST_PATH", ""))
     task_manifest = {}
     if task_manifest_path.exists():
@@ -1330,6 +1390,14 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "teamStatePath": ctx.get("TEAM_STATE_RELATIVE_PATH", ""),
         "activeRunContextPath": ctx.get("ACTIVE_RUN_CONTEXT_RELATIVE_PATH", ""),
         "analysisPacketPath": ctx.get("ANALYSIS_PACKET_RELATIVE_PATH", ""),
+        "analysisEvidencePath": (
+            ctx.get("INSTRUCTION_SET_RELATIVE_PATH", "") + "/analysis-evidence.md"
+            if ctx.get("TASK_TYPE") in {"project-analysis", "feature-analysis", "change-impact-analysis"}
+            else ""
+        ),
+        "analysisSourceCommit": ctx.get("ANALYSIS_SOURCE_COMMIT", ""),
+        "analysisTarget": json.loads(ctx.get("ANALYSIS_TARGET_JSON", "{}")),
+        "evidenceInputs": json.loads(ctx.get("EVIDENCE_INPUTS_JSON", "[]")),
         "verificationTargetPath": ctx.get("VERIFICATION_TARGET_RELATIVE_PATH", ""),
         "verificationTargetDigest": ctx.get("VERIFICATION_TARGET_DIGEST", ""),
         "workerResultsDirectoryPath": ctx.get("WORKER_RESULTS_RELATIVE_PATH", ""),
@@ -1403,6 +1471,11 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         "renderOnly": ctx.get("RENDER_ONLY", ""),
         "createdAt": ctx.get("RUN_TIMESTAMP_ISO", ""),
     }
+    scope_confirmation = existing_run_manifest.get("analysisScopeConfirmation")
+    if "analysisScopeConfirmation" not in existing_run_manifest:
+        scope_confirmation = _analysis_scope_confirmation_snapshot(ctx)
+    if scope_confirmation is not None:
+        payload["analysisScopeConfirmation"] = scope_confirmation
     if ctx.get("FIX_CYCLE_ID"):
         payload["fixCycleId"] = ctx["FIX_CYCLE_ID"]
     payload["reportContracts"] = (

package/runtime/python/okstra_ctl/render_final_report.py

@@ -67,7 +67,7 @@ class FinalReportRenderError(RuntimeError):
 
 
 def _format_int(value: Any) -> str:
-    if value is None:
+    if value is None or not isinstance(value, (str, int, float)):
         return "--"
     try:
         return f"{int(value):,}"
@@ -76,7 +76,7 @@ def _format_int(value: Any) -> str:
 
 
 def _format_usd(value: Any) -> str:
-    if value is None:
+    if value is None or not isinstance(value, (str, int, float)):
         return "--"
     try:
         return f"${float(value):.2f}"
@@ -85,7 +85,7 @@ def _format_usd(value: Any) -> str:
 
 
 def _format_duration_ms(value: Any) -> str:
-    if value is None:
+    if value is None or not isinstance(value, (str, int, float)):
         return "--"
     try:
         ms = int(value)
@@ -583,10 +583,16 @@ def resolve_report_language(data: dict, *, override: str | None) -> str:
 # through, `| length` raises on it, and both `x` and `not x` evaluate true. So a
 # template cannot test for absence at all, and the value has to arrive filled.
 _OPTIONAL_ARRAY_DEFAULTS = ("endStateCoverage",)
+_OPTIONAL_ANALYSIS_DEFAULTS = (
+    "analysisCommon",
+    "projectAnalysis",
+    "featureAnalysis",
+    "changeImpactAnalysis",
+)
 
 
 def _with_optional_defaults(data: dict) -> dict:
-    """Render context with schema-optional arrays filled in.
+    """Render context with schema-optional fields filled in.
 
     Keeps the schema field optional — an omitted `endStateCoverage` stays absent
     in data.json, which is what the run validator reads to tell a legacy brief
@@ -597,6 +603,9 @@ def _with_optional_defaults(data: dict) -> dict:
     for key in _OPTIONAL_ARRAY_DEFAULTS:
         if not isinstance(filled.get(key), list):
             filled[key] = []
+    for key in _OPTIONAL_ANALYSIS_DEFAULTS:
+        if not isinstance(filled.get(key), dict):
+            filled[key] = None
     return filled
 
 

package/runtime/python/okstra_ctl/report_views.py

@@ -108,6 +108,11 @@ class RunMeta:
     source_report: str  # relative path of the .md the HTML is derived from
 
 
+@dataclass(frozen=True)
+class AnalysisReviewContext:
+    selector_ids: tuple[str, ...]
+
+
 # task-type itself can contain hyphens (``implementation-planning``,
 # ``final-verification``, ``release-handoff``), so the filename segment
 # between ``final-report-`` and ``-<seq>.md`` is matched greedily; the
@@ -159,6 +164,7 @@ class ReportViewModel:
     sidecar_dir: str
     approval_ctx: PlanApprovalContext | None = None
     reader_ctx: ReaderDashboardContext | None = None
+    analysis_review_ctx: AnalysisReviewContext | None = None
 
 
 @dataclass(frozen=True)
@@ -179,6 +185,7 @@ def build_report_view_model(
     run_meta: RunMeta,
     approval_ctx: PlanApprovalContext | None = None,
     reader_ctx: ReaderDashboardContext | None = None,
+    analysis_review_ctx: AnalysisReviewContext | None = None,
 ) -> ReportViewModel:
     digest = source_digest(src_md)
     body_md = _strip_leading_frontmatter(src_md)
@@ -197,6 +204,7 @@ def build_report_view_model(
         sidecar_dir=f"runs/{run_meta.task_type}/user-responses/",
         approval_ctx=approval_ctx,
         reader_ctx=reader_ctx,
+        analysis_review_ctx=analysis_review_ctx,
     )
 
 
@@ -258,6 +266,7 @@ def render_report_view_model(
         f"</header>\n"
         f"<main>{_reader_dashboard(model.reader_ctx)}{model.body_html}</main>\n"
         f"{_plan_approval_section(model.approval_ctx, run_meta) if model.approval_ctx else ''}"
+        f"{_analysis_review_section(model.analysis_review_ctx) if model.analysis_review_ctx else ''}"
         f"<footer class=\"report-footer\">\n"
         f"  <button type=\"button\" data-action=\"export-user-response\">Export user response</button>\n"
         f"  <p class=\"user-response-hint\">Export 클릭 시 <code>{sidecar_name}</code> 가 다운로드됩니다 — "
@@ -288,6 +297,7 @@ def render_html(
     js: str,
     approval_ctx: PlanApprovalContext | None = None,
     reader_ctx: ReaderDashboardContext | None = None,
+    analysis_review_ctx: AnalysisReviewContext | None = None,
 ) -> str:
     """Return a single self-contained HTML document for ``src_md``.
 
@@ -300,6 +310,7 @@ def render_html(
         run_meta=run_meta,
         approval_ctx=approval_ctx,
         reader_ctx=reader_ctx,
+        analysis_review_ctx=analysis_review_ctx,
     )
     return render_report_view_model(model, css=css, js=js)
 
@@ -1021,12 +1032,56 @@ class UserResponseApproval:
     implementation_option: str = ""
 
 
+@dataclass(frozen=True)
+class UserResponseAnalysisReview:
+    status: str
+    affected_ids: tuple[str, ...] = ()
+    reason: str = ""
+    additional_evidence: str = ""
+    requested_scope_change: str = ""
+
+
+_ANALYSIS_REVIEW_STATUSES = frozenset({
+    "accepted",
+    "revision-requested",
+    "rejected",
+})
+
+
+def _quoted_sidecar_field(label: str, value: str) -> str:
+    cleaned = value.strip()
+    if not cleaned:
+        return f"- {label}:\n"
+    quoted = "".join(f"  > {line}\n" for line in cleaned.split("\n"))
+    return f"- {label}:\n{quoted}"
+
+
+def _serialize_analysis_review(review: UserResponseAnalysisReview) -> str:
+    if review.status not in _ANALYSIS_REVIEW_STATUSES:
+        raise ValueError(f"invalid ANALYSIS REVIEW status: {review.status}")
+    if review.status in {"revision-requested", "rejected"} and (
+        not review.affected_ids or not review.reason.strip()
+    ):
+        raise ValueError(
+            f"ANALYSIS REVIEW {review.status} requires Affected-IDs and Reason"
+        )
+    return (
+        "\n## ANALYSIS REVIEW\n"
+        f"- Status: {review.status}\n"
+        f"- Affected-IDs: {', '.join(review.affected_ids)}\n"
+        f"{_quoted_sidecar_field('Reason', review.reason)}"
+        f"{_quoted_sidecar_field('Additional-Evidence', review.additional_evidence)}"
+        f"{_quoted_sidecar_field('Requested-Scope-Change', review.requested_scope_change)}"
+    )
+
+
 def serialize_user_response(
     *,
     run_meta: RunMeta,
     entries: list[UserResponseEntry],
     created_at: str,
     approval: UserResponseApproval | None = None,
+    analysis_review: UserResponseAnalysisReview | None = None,
 ) -> str:
     """Return the canonical markdown text the HTML 'Export user
     response' button must produce. Used by validators to confirm that
@@ -1046,6 +1101,7 @@ def serialize_user_response(
         "# User Response\n"
     )
     has_approval = approval is not None and approval.approved
+    has_analysis_review = analysis_review is not None
     body_chunks: list[str] = []
     for e in entries:
         chunk = f"\n## {e.response_id}\n- Kind: {e.kind}\n"
@@ -1056,13 +1112,15 @@ def serialize_user_response(
         if e.rationale:
             chunk += f"- Rationale: {e.rationale.strip()}\n"
         body_chunks.append(chunk)
-    if not entries and not has_approval:
+    if not entries and not has_approval and not has_analysis_review:
         body_chunks.append("\n_(No user responses recorded.)_\n")
     if has_approval:
         chunk = "\n## APPROVAL\n- Approved: true\n"
         if approval.implementation_option:
             chunk += f"- Implementation-Option: {approval.implementation_option.strip()}\n"
         body_chunks.append(chunk)
+    if analysis_review is not None:
+        body_chunks.append(_serialize_analysis_review(analysis_review))
     return head + "".join(body_chunks)
 
 
@@ -1107,6 +1165,39 @@ def _load_report_data(src_md_path: Path) -> dict | None:
     return data if isinstance(data, dict) else None
 
 
+_ANALYSIS_DATA_KEYS = (
+    "analysisCommon",
+    "projectAnalysis",
+    "featureAnalysis",
+    "changeImpactAnalysis",
+)
+_STRUCTURED_ANALYSIS_ID_RE = re.compile(r"^[A-Z]{2}-\d{3}$")
+
+
+def _collect_structured_analysis_ids(value: object, found: set[str]) -> None:
+    if isinstance(value, dict):
+        candidate = value.get("id")
+        if isinstance(candidate, str) and _STRUCTURED_ANALYSIS_ID_RE.fullmatch(
+            candidate
+        ):
+            found.add(candidate)
+        for child in value.values():
+            _collect_structured_analysis_ids(child, found)
+    elif isinstance(value, list):
+        for child in value:
+            _collect_structured_analysis_ids(child, found)
+
+
+def analysis_review_context(src_md_path: Path) -> AnalysisReviewContext | None:
+    data = _load_report_data(src_md_path)
+    if data is None or not isinstance(data.get("analysisCommon"), dict):
+        return None
+    found: set[str] = set()
+    for key in _ANALYSIS_DATA_KEYS:
+        _collect_structured_analysis_ids(data.get(key), found)
+    return AnalysisReviewContext(selector_ids=tuple(sorted(found)))
+
+
 def plan_approval_context(
     src_md_path: Path, src_text: str
 ) -> PlanApprovalContext | None:
@@ -1298,6 +1389,35 @@ def _plan_approval_section(ctx: PlanApprovalContext, run_meta: RunMeta) -> str:
     )
 
 
+def _analysis_review_section(ctx: AnalysisReviewContext) -> str:
+    options = "".join(
+        f'<option value="{html.escape(analysis_id)}">'
+        f"{html.escape(analysis_id)}</option>"
+        for analysis_id in ctx.selector_ids
+    )
+    return (
+        '<section id="analysis-review">\n'
+        "  <h2>Analysis Review</h2>\n"
+        '  <fieldset><legend>Decision</legend>\n'
+        '    <label><input type="radio" name="analysis-review-status" '
+        'value="accepted">Accept</label>\n'
+        '    <label><input type="radio" name="analysis-review-status" '
+        'value="revision-requested">Request revision</label>\n'
+        '    <label><input type="radio" name="analysis-review-status" '
+        'value="rejected">Reject</label>\n'
+        "  </fieldset>\n"
+        '  <label>Affected IDs <select id="analysis-review-affected-ids" '
+        f'multiple>{options}</select></label>\n'
+        '  <label>Reason <textarea id="analysis-review-reason" rows="3">'
+        "</textarea></label>\n"
+        '  <label>Additional evidence <textarea id="analysis-review-evidence" '
+        'rows="3"></textarea></label>\n'
+        '  <label>Requested scope change <textarea '
+        'id="analysis-review-scope-change" rows="3"></textarea></label>\n'
+        "</section>\n"
+    )
+
+
 def render_html_view(
     src_md_path: Path,
     *,
@@ -1327,9 +1447,15 @@ def render_html_view(
             "the HTML view."
         )
     approval_ctx = plan_approval_context(src_md_path, src_text)
+    analysis_review_ctx = analysis_review_context(src_md_path)
     reader_ctx = reader_dashboard_context(src_md_path, src_text, approval_ctx)
     has_clarifications = report_has_clarification_items(src_text)
-    if not has_clarifications and approval_ctx is None and reader_ctx is None:
+    if (
+        not has_clarifications
+        and approval_ctx is None
+        and reader_ctx is None
+        and analysis_review_ctx is None
+    ):
         if html_path.is_file():
             html_path.unlink()
         return None
@@ -1340,9 +1466,14 @@ def render_html_view(
         js=js,
         approval_ctx=approval_ctx,
         reader_ctx=reader_ctx,
+        analysis_review_ctx=analysis_review_ctx,
     )
     html_path.write_text(html_text, encoding="utf-8")
-    if has_clarifications or approval_ctx is not None:
+    if (
+        has_clarifications
+        or approval_ctx is not None
+        or analysis_review_ctx is not None
+    ):
         # 사용자 확인(폼/승인)이 필요한 보고서 — Export 파일의 저장 위치를 미리
         # 만들어 사용자가 디렉토리를 만들 필요가 없게 한다 (reports/ 의 sibling).
         user_responses_dir_for_report(src_md_path).mkdir(parents=True, exist_ok=True)

package/runtime/python/okstra_ctl/run.py

@@ -31,6 +31,15 @@ from okstra_project import project_json_path, upsert_project_json
 from okstra_project.state import slugify
 from . import fix_cycles
 from .analysis_packet import build_analysis_packet
+from .analysis_inputs import (
+    ANALYSIS_TASK_TYPES,
+    AnalysisInputError,
+    load_candidate_map,
+    parse_evidence_paths,
+    resolve_analysis_head,
+    resolve_analysis_target,
+    resolve_evidence_inputs,
+)
 from .stage_fix_carry import derive_stage_fix_carry
 from .clarification_items import (
     attached_user_responses_section,
@@ -71,6 +80,7 @@ from okstra_project.dirs import okstra_home
 
 from .run_context import (
     compute_and_write_run_context,
+    refresh_run_context_snapshot,
     write_run_inputs,
 )
 from .seeding import (
@@ -311,6 +321,8 @@ class PrepareInputs:
     task_id: str
     task_type: str
     brief_path: Path  # absolute, already resolved
+    analysis_target: str = ""
+    evidence_inputs_raw: str = ""
     directive: str = ""
     workers_override: str = ""
     lead_model: str = ""
@@ -758,6 +770,8 @@ def _canonical_argv(inp: PrepareInputs, ctx: dict) -> list[str]:
         ("--task-group", inp.task_group),
         ("--task-id", inp.task_id),
         ("--task-brief", str(inp.brief_path)),
+        ("--analysis-target", inp.analysis_target),
+        ("--evidence-inputs", inp.evidence_inputs_raw),
         ("--directive", inp.directive),
         ("--approved-plan", inp.approved_plan_path),
         ("--implementation-option", inp.implementation_option),
@@ -946,6 +960,7 @@ def _validate_prepare_inputs(project_root: Path, inp: PrepareInputs) -> list:
     """Validate pure prepare inputs and return a final-verification stage map."""
     if not project_root.is_dir():
         raise PrepareError(f"project root not found: {project_root}")
+    _validate_analysis_prepare_inputs(project_root, inp)
     if inp.stages and inp.task_type != "release-handoff":
         raise PrepareError(
             "--stages is only meaningful with --task-type release-handoff; "
@@ -1028,6 +1043,41 @@ def _prepare_implementation_approved_plan(inp: PrepareInputs) -> list:
     return _parse_stage_map_into_ctx(inp.approved_plan_path)
 
 
+def _validate_analysis_prepare_inputs(project_root: Path, inp: PrepareInputs) -> None:
+    """Reject invalid analysis inputs before task worktree or run sequence creation."""
+    is_analysis = inp.task_type in ANALYSIS_TASK_TYPES
+    if not is_analysis:
+        if inp.analysis_target:
+            raise PrepareError(
+                f"--analysis-target is only accepted for analysis task types; got {inp.task_type}"
+            )
+        if inp.evidence_inputs_raw:
+            raise PrepareError(
+                f"--evidence-inputs is only accepted for analysis task types; got {inp.task_type}"
+            )
+        return
+    if inp.task_type == "project-analysis":
+        if inp.analysis_target:
+            raise PrepareError("project-analysis does not accept an analysis target")
+        if inp.evidence_inputs_raw:
+            raise PrepareError("project-analysis does not accept evidence inputs")
+        return
+    if inp.task_type == "feature-analysis" and not inp.analysis_target.strip():
+        raise PrepareError("feature-analysis requires --analysis-target")
+    if inp.task_type != "feature-analysis" and inp.analysis_target:
+        raise PrepareError(f"{inp.task_type} does not accept an analysis target")
+    paths = parse_evidence_paths(inp.evidence_inputs_raw, project_root)
+    try:
+        candidates = load_candidate_map(project_root, paths)
+        evidence = resolve_evidence_inputs(
+            project_root, inp.task_type, paths, "0" * 40,
+        )
+        if inp.task_type == "feature-analysis":
+            resolve_analysis_target(inp.analysis_target, evidence, candidates)
+    except AnalysisInputError as exc:
+        raise PrepareError(str(exc)) from exc
+
+
 def _collect_handoff_source_report_rows(
     rows: list, nums: list,
 ) -> list:
@@ -1583,6 +1633,7 @@ def _write_instruction_set_sources(
     reference-expectations 를 기록하고 디렉터리 경로를 돌려준다."""
     instruction_set = Path(ctx["INSTRUCTION_SET_PATH"])
     instruction_set.mkdir(parents=True, exist_ok=True)
+    _write_analysis_evidence_artifact(ctx, instruction_set)
     _write_verification_target_artifact(inp, ctx, instruction_set)
     profile_rendered = profile_content
     if inp.task_type == "implementation":
@@ -1658,10 +1709,43 @@ def _write_instruction_set_sources(
         fix_history_text=fix_cycles.packet_summary(
             fix_cycles.read_rows(Path(ctx["TASK_MANIFEST_PATH"]).parent)),
     )
+    if inp.task_type in ANALYSIS_TASK_TYPES:
+        packet += (
+            "\n## Analysis Evidence\n\n"
+            f"- Analysis evidence: `{ctx['INSTRUCTION_SET_RELATIVE_PATH']}/analysis-evidence.md`\n"
+        )
     (instruction_set / "analysis-packet.md").write_text(packet, encoding="utf-8")
     return instruction_set
 
 
+def _write_analysis_evidence_artifact(ctx: dict, instruction_set: Path) -> None:
+    """Write selected evidence metadata without copying the original reports."""
+    if ctx.get("TASK_TYPE") not in ANALYSIS_TASK_TYPES:
+        return
+    evidence = json.loads(ctx.get("EVIDENCE_INPUTS_JSON", "[]"))
+    lines = [
+        "# Analysis Evidence",
+        "",
+        "Revalidate every cited finding against the current code before relying on it.",
+    ]
+    for item in evidence:
+        lines.extend([
+            "",
+            f"## {item['taskType']} / run {item['runSeq']}",
+            "",
+            f"- Metadata: task key `{item['taskKey']}`, source commit `{item['sourceCommit']}`, relation `{item['relation']}`",
+            f"- Original report: `{item['reportPath']}`",
+            f"- Review status: `{item['reviewStatus']}`",
+            f"- Freshness: `{item['freshness']}`",
+            "- Current-code obligation: revalidate cited findings against the current code.",
+        ])
+    if not evidence:
+        lines.extend(["", "- No evidence reports were selected."])
+    (instruction_set / "analysis-evidence.md").write_text(
+        "\n".join(lines) + "\n", encoding="utf-8",
+    )
+
+
 def _render_lead_prompt_and_snapshot(
     inp: PrepareInputs,
     ctx: dict,
@@ -1744,6 +1828,10 @@ def _persist_run_inputs(
             "relatedTasks": inp.related_tasks_raw,
             "approvedPlanPath": approved_plan_path,
             "clarificationResponsePath": inp.clarification_response_path,
+            "analysisTarget": json.loads(ctx.get("ANALYSIS_TARGET_JSON", "{}")).get(
+                "requestedValue", ""
+            ),
+            "evidenceInputs": json.loads(ctx.get("EVIDENCE_INPUTS_JSON", "[]")),
             "renderOnly": inp.render_only,
         },
     )
@@ -2169,6 +2257,26 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     stage_run_claim = provisioned.stage_run_claim
     stage_arg = provisioned.stage_arg
 
+    analysis_source_commit = ""
+    resolved_evidence = ()
+    resolved_target: dict[str, object] = {}
+    if inp.task_type in ANALYSIS_TASK_TYPES:
+        analysis_root = Path(worktree.path or project_root)
+        evidence_paths = parse_evidence_paths(inp.evidence_inputs_raw, project_root)
+        try:
+            analysis_source_commit = resolve_analysis_head(analysis_root)
+            resolved_evidence = resolve_evidence_inputs(
+                project_root, inp.task_type, evidence_paths, analysis_source_commit,
+            )
+            if inp.task_type == "feature-analysis":
+                resolved_target = resolve_analysis_target(
+                    inp.analysis_target,
+                    resolved_evidence,
+                    load_candidate_map(project_root, evidence_paths),
+                )
+        except AnalysisInputError as exc:
+            raise PrepareError(str(exc)) from exc
+
     ctx = compute_and_write_run_context(
         workspace_root=workspace_root, project_root=project_root,
         project_id=inp.project_id, task_group=inp.task_group, task_id=inp.task_id,
@@ -2189,6 +2297,11 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "OKSTRA_PLAN_VERIFICATION": (
             "false" if not inp.plan_verification_enabled else ""
         ),
+        "ANALYSIS_SOURCE_COMMIT": analysis_source_commit,
+        "ANALYSIS_TARGET_JSON": json.dumps(resolved_target, ensure_ascii=False),
+        "EVIDENCE_INPUTS_JSON": json.dumps(
+            [item.to_dict() for item in resolved_evidence], ensure_ascii=False,
+        ),
     })
 
     # implementation: override the task-worktree fields with the claimed
@@ -2254,6 +2367,7 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         "RENDER_ONLY": "true" if inp.render_only else "false",
         "OKSTRA_VERSION": installed_version(),
     })
+    refresh_run_context_snapshot(ctx)
     if lead_runtime == "codex":
         ctx["CLAUDE_RESUME_COMMAND_PATH"] = ""
         ctx["CLAUDE_RESUME_COMMAND_RELATIVE_PATH"] = ""
@@ -2328,6 +2442,8 @@ def main(argv: list[str]) -> int:
         ),
     )
     p.add_argument("--directive", default="")
+    p.add_argument("--analysis-target", default="", dest="analysis_target")
+    p.add_argument("--evidence-inputs", default="", dest="evidence_inputs_raw")
     p.add_argument(
         "--fix-cycle", default="", choices=["", "yes", "no"], dest="fix_cycle",
         help=(
@@ -2502,6 +2618,8 @@ def main(argv: list[str]) -> int:
         task_id=args.task_id,
         task_type=args.task_type,
         brief_path=brief_abs,
+        analysis_target=args.analysis_target,
+        evidence_inputs_raw=args.evidence_inputs_raw,
         directive=args.directive,
         workers_override=args.workers_override,
         lead_model=args.lead_model,