okstra 0.144.0 → 0.145.0

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,

package/runtime/python/okstra_ctl/run_context.py

@@ -193,6 +193,20 @@ def compute_and_write_run_context(
     return ctx
 
 
+def refresh_run_context_snapshot(ctx: dict) -> None:
+    """Rewrite a run context after prepare resolves run-scoped inputs."""
+    payload = compact_run_context(ctx)
+    payload["analysis"] = {
+        "sourceCommit": ctx.get("ANALYSIS_SOURCE_COMMIT", ""),
+        "target": json.loads(ctx.get("ANALYSIS_TARGET_JSON", "{}")),
+        "evidenceInputs": json.loads(ctx.get("EVIDENCE_INPUTS_JSON", "[]")),
+    }
+    payload["ANALYSIS_SOURCE_COMMIT"] = ctx.get("ANALYSIS_SOURCE_COMMIT", "")
+    payload["ANALYSIS_TARGET_JSON"] = ctx.get("ANALYSIS_TARGET_JSON", "{}")
+    payload["EVIDENCE_INPUTS_JSON"] = ctx.get("EVIDENCE_INPUTS_JSON", "[]")
+    _atomic_write_json(Path(ctx["RUN_CONTEXT_FILE"]), payload)
+
+
 def write_run_inputs(
     *,
     project_root: Path,
@@ -207,7 +221,7 @@ def write_run_inputs(
     inputs schema (모든 키 optional):
       taskBriefPath, directive, workers, leadModel, claudeModel, codexModel,
       antigravityModel, reportWriterModel, relatedTasks, approvedPlanPath,
-      clarificationResponsePath, renderOnly
+      clarificationResponsePath, analysisTarget, evidenceInputs, renderOnly
     """
     run_manifests_dir = Path(run_manifests_dir)
     path = run_manifests_dir / _run_inputs_filename(task_type_segment, seq)
@@ -227,7 +241,25 @@ def read_run_context(run_manifests_dir: Path, task_type_segment: str,
     if not path.is_file():
         return None
     payload = json.loads(path.read_text(encoding="utf-8"))
-    return hydrate_run_context(payload)
+    context = hydrate_run_context(payload)
+    analysis = payload.get("analysis")
+    if isinstance(analysis, dict):
+        target_json = payload.get("ANALYSIS_TARGET_JSON")
+        if not isinstance(target_json, str):
+            target_json = json.dumps(analysis.get("target", {}), ensure_ascii=False)
+        evidence_json = payload.get("EVIDENCE_INPUTS_JSON")
+        if not isinstance(evidence_json, str):
+            evidence_json = json.dumps(
+                analysis.get("evidenceInputs", []), ensure_ascii=False,
+            )
+        context.update({
+            "ANALYSIS_SOURCE_COMMIT": str(
+                payload.get("ANALYSIS_SOURCE_COMMIT", analysis.get("sourceCommit", ""))
+            ),
+            "ANALYSIS_TARGET_JSON": target_json,
+            "EVIDENCE_INPUTS_JSON": evidence_json,
+        })
+    return context
 
 
 def read_run_inputs(run_manifests_dir: Path, task_type_segment: str,

package/runtime/python/okstra_ctl/schema_excerpt.py

@@ -1,9 +1,9 @@
 """Build a task-type-scoped excerpt of the final-report schema.
 
 The full schema (``schemas/final-report-v1.0.schema.json``) carries the
-deliverable property blocks for ALL task-types (``errorAnalysis``,
-``implementationPlanning``, ``releaseHandoff``, ``implementation``,
-``finalVerification``) plus a
+deliverable property blocks for ALL task-types (``errorAnalysis``, the three
+read-only analysis blocks, ``implementationPlanning``, ``releaseHandoff``,
+``implementation``, and ``finalVerification``) plus a
 ``$defs`` library (~38% of the file) shared across them. A single run only
 authors ONE task-type's data.json, so the report-writer worker only needs
 the common structure + its own task-type's block + the ``$defs`` those
@@ -27,15 +27,21 @@ import re
 # task-type → the per-type deliverable property key it owns. task-types
 # absent from this map (requirements-discovery,
 # improvement-discovery) have no per-type block; their excerpt keeps only
-# the common properties.
+# the non-analysis common properties.
 _TASK_TYPE_PROPERTY = {
     "error-analysis": "errorAnalysis",
+    "project-analysis": "projectAnalysis",
+    "feature-analysis": "featureAnalysis",
+    "change-impact-analysis": "changeImpactAnalysis",
     "implementation-planning": "implementationPlanning",
     "release-handoff": "releaseHandoff",
     "implementation": "implementation",
     "final-verification": "finalVerification",
 }
 _ALL_PER_TYPE_PROPERTIES = frozenset(_TASK_TYPE_PROPERTY.values())
+_ANALYSIS_COMMON_TASK_TYPES = frozenset(
+    {"project-analysis", "feature-analysis", "change-impact-analysis"}
+)
 
 _REF_RE = re.compile(r'"\$ref"\s*:\s*"#/\$defs/([^"]+)"')
 
@@ -100,6 +106,8 @@ def build_schema_excerpt(schema: dict, task_type: str, cut_from_version: str = "
     """
     keep_per_type = _TASK_TYPE_PROPERTY.get(task_type)
     drop_props = _ALL_PER_TYPE_PROPERTIES - ({keep_per_type} if keep_per_type else set())
+    if task_type not in _ANALYSIS_COMMON_TASK_TYPES:
+        drop_props = drop_props | {"analysisCommon"}
 
     props = {
         k: v for k, v in schema.get("properties", {}).items() if k not in drop_props