okstra 0.220.0 → 0.221.0

package/runtime/python/okstra_ctl/adapters/providers/grok/adapter.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Any, Mapping
 from urllib.parse import quote
 
+from okstra_ctl.domain.mcp import McpInventory, McpInventoryProbe, VisibleMcpServer
 from okstra_ctl.domain.provider import (
     LeadLaunchSpec,
     ModelSpec,
@@ -292,6 +293,29 @@ class GrokExecution:
         )
 
 
+def parse_mcp_list(stdout: str) -> McpInventory:
+    """실측은 빈 목록뿐이었다(grok 1.0.46). 행 형식을 모르므로 `name` 이 없는
+    행은 빈 목록이 아니라 판정 불가로 돌린다."""
+    try:
+        rows = json.loads(stdout)
+    except json.JSONDecodeError as exc:
+        return McpInventory.unavailable(f"grok mcp list --json is not JSON ({exc})")
+    if not isinstance(rows, list):
+        return McpInventory.unavailable("grok mcp list --json is not a list")
+    servers: list[VisibleMcpServer] = []
+    for row in rows:
+        if not isinstance(row, dict) or not isinstance(row.get("name"), str):
+            return McpInventory.unavailable("grok mcp list --json row has no name field")
+        enabled = row.get("enabled", True) is not False
+        servers.append(VisibleMcpServer(row["name"], "enabled" if enabled else "disabled"))
+    return McpInventory(listed=True, servers=tuple(servers))
+
+
+MCP_INVENTORY = McpInventoryProbe(
+    argv=("grok", "mcp", "list", "--json"), parse=parse_mcp_list,
+)
+
+
 def create_provider() -> ProviderSpec:
     return ProviderSpec(
         provider="grok",
@@ -324,4 +348,5 @@ def create_provider() -> ProviderSpec:
         lead_launch=GROK_LEAD_LAUNCH,
         exec_strategy=GrokExecution(),
         served_model_normalizer=normalise_served_model,
+        mcp_inventory=MCP_INVENTORY,
     )

package/runtime/python/okstra_ctl/adapters/providers/zai/adapter.py

@@ -7,7 +7,11 @@ from dataclasses import replace
 from pathlib import Path
 from typing import Any
 
-from okstra_ctl.adapters.providers.claude.adapter import ClaudeExecution
+from okstra_ctl.adapters.providers.claude.adapter import (
+    ClaudeExecution,
+    parse_mcp_list as _claude_mcp_list,
+)
+from okstra_ctl.domain.mcp import McpInventory, McpInventoryProbe
 from okstra_ctl.domain.provider import ModelSpec, ProviderSpec, ServedModelAttestation
 from okstra_ctl.domain.role import ROLE_DEFINITIONS
 from okstra_ctl.domain.worker_exec import ExecCommand, PolicySupport, WorkerExecRequest
@@ -111,6 +115,20 @@ class ZaiExecution:
         return ClaudeExecution().policy_support()
 
 
+def parse_mcp_list(stdout: str) -> McpInventory:
+    """워커는 `--setting-sources ""` 로 떠서 사용자 범위 서버는 빠지고 claude.ai
+    커넥터만 남는다(2026-10-18, claude 2.1.302 실측)."""
+    listed = _claude_mcp_list(stdout)
+    return McpInventory(
+        listed=True,
+        servers=tuple(s for s in listed.servers if s.name.startswith("claude.ai ")),
+        note="calls through the z.ai backend are not verified",
+    )
+
+
+MCP_INVENTORY = McpInventoryProbe(argv=("claude", "mcp", "list"), parse=parse_mcp_list)
+
+
 def create_provider() -> ProviderSpec:
     roles = frozenset(role.id for role in ROLE_DEFINITIONS if role.id != "leader")
     return ProviderSpec(
@@ -126,4 +144,5 @@ def create_provider() -> ProviderSpec:
         }),
         exec_strategy=ZaiExecution(),
         served_model_normalizer=normalise_served_model,
+        mcp_inventory=MCP_INVENTORY,
     )

package/runtime/python/okstra_ctl/agent/prompt_cli/materialize.py

@@ -340,6 +340,9 @@ def _materialize_run(
             ),
         )
     if args.audience == "report-writer" and uses_report_contract_v3(manifest):
+        # 조립이 `meta.reportLanguage` 로 옮기는 값과 같은 출처여야 한다.
+        report_language = str(manifest.get("reportLanguage") or "en")
+        anchor_lines = anchor_lines + (f"**Report Language:** {report_language}",)
         body = _with_report_writer_sections(
             args,
             project_root,

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -65,6 +65,7 @@ WORKER_PROFILE_SECTIONS_BY_TASK_TYPE = {
         "Worker direction-selection procedure",
         "Pre-selection context exploration",
         "Option evaluation rules",
+        "Technical evidence loop",
     ),
     "implementation-planning": (
         "Brief consumption",
@@ -114,6 +115,8 @@ def build_analysis_packet(
     business_knowledge_text: str = "",
     coverage_census_text: str = "",
     has_selected_direction: bool = False,
+    mcp_servers_text: str = "",
+    technical_evidence_text: str = "",
 ) -> str:
     """Return the primary compact input for Claude/Codex/Antigravity analysers.
 
@@ -130,6 +133,12 @@ def build_analysis_packet(
 
     `coverage_census_text` is the `## Coverage Census` block
     `coverage_census.render_census_section` rendered; empty means no census.
+
+    `mcp_servers_text` 는 prepare 가 provider 별 도달성까지 렌더한 선언 서버
+    목록이다. 빈 문자열이면 선언이 없는 것이고 절을 싣지 않는다.
+
+    `technical_evidence_text` 는 carry-in 이 technical-verification 결과일 때
+    `technical_evidence_packet_block` 이 렌더한 증거 위치 절이다.
     """
     brief_text = task_brief_path.read_text(encoding="utf-8")
     group_context_text = _read_optional(group_context_path) if group_context_path else ""
@@ -150,6 +159,9 @@ def build_analysis_packet(
             has_selected_direction,
         )
     )
+    # 짧은 포인터 절이라 46KB 에서 잘리는 읽기에서도 도착하도록 브리프보다 앞에 둔다.
+    if technical_evidence_text:
+        parts.extend(["", technical_evidence_text])
     # 그룹 문서는 사람 절과 okstra 메모리 영역으로 갈라 싣는다. 사람 절("왜")은
     # 브리프 발췌보다 앞 — 짧고, 46KB 에서 잘리는 읽기(agy view_file)에서도
     # 도착해야 한다. 형제 task 의 결론은 브리프 뒤 — 브리프를 밀어내면 안 된다.
@@ -158,6 +170,8 @@ def build_analysis_packet(
     )
     parts.extend(_group_context_block(group_human))
     parts.extend(_brief_block(brief_text))
+    if mcp_servers_text:
+        parts.extend(["", "## Available MCP Servers", "", mcp_servers_text])
     if direct_work_text:
         parts.extend(["", direct_work_text, ""])
     parts.extend(_group_memory_block(

package/runtime/python/okstra_ctl/business_flow/engine.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import hashlib
 import json
+import re
 from dataclasses import asdict, replace
 from datetime import datetime, timezone
 from pathlib import Path
@@ -197,10 +198,15 @@ def _accept_return(call: PreparedCall, returned: bytes) -> str:
     ).returned_body
 
 
+_FENCED_JSON = re.compile(r"^```json\n(.*?)\n```$", re.MULTILINE | re.DOTALL)
+
+
 def _parse_result(body: str, path: Path) -> BusinessResult:
     text = body.strip()
-    if text.startswith("```json\n") and text.endswith("\n```"):
-        text = text[8:-4]
+    # 조사자는 "JSON만 반환" 지시에도 객체를 짧은 서문·맺음말과 함께 펜스로 감싸 돌려준다.
+    fenced = _FENCED_JSON.findall(text)
+    if len(fenced) == 1:
+        text = fenced[0]
     try:
         result = json.loads(text)
     except json.JSONDecodeError as exc:
@@ -379,6 +385,8 @@ def _instructions(
             "Return only one JSON object matching the schema below.",
             "Read the listed source roots and source artifacts only. Do not edit files, execute tests, start services, deploy or migrate.",
             "Inspect inbound AND outbound dependencies across all candidates, including indirect call/event/queue/shared-data/file/batch relationships. Name every uninspected candidate or missing branch in gaps.",
+            "In relationships, from and to must each be a projectId listed under projects in the Source Material; put modules, files and planned work in data, not in from/to.",
+            "Cite evidence only from files Git tracks or would add in a candidate root. Git-ignored files (for example .project-docs/) are outside the captured source inventory and are rejected; name what you learned from them in gaps instead.",
             "Explain the product business from start to finish for a new developer: purpose, rules, input/output, states, failure, retry and recovery. Link each step and relationship to factKeys.",
             "Use stable keys in business/subject/attribute form. Facts are source-backed assertions; expected changes remain expected. Cite inspected evidence with one-based line/endLine; each excerpt must copy the whole line..endLine range verbatim, including indentation, with no elision or omitted lines. Tests are static evidence unless a supplied existing verification record supports the execution claim.",
             "For post mode, use the supplied project-specific baseline. Never invent missing before-state. Describe the actual delta and distinguish confirmed side effects from risks.",

package/runtime/python/okstra_ctl/correction_cli.py

@@ -2,23 +2,46 @@
 from __future__ import annotations
 
 import argparse
+import subprocess
 import sys
 from pathlib import Path
 
 from .convergence import canonical_run_state_artifact, validated_run_authority
 from .correction_round import CorrectionRoundError, correction_instruction
+from .file_size_cap import FILE_LINE_LIMIT, FILE_LINE_TARGET, file_size_violations
 
 
 _CLI_EPILOG = r"""Usage:
   okstra correction prompt --run-manifest <path> --round <N> --role <executor|verifier> \
-    --base <sha> --finding <F-id> [--finding <F-id> ...]
+    --base <sha> [--finding <F-id> ...] [--stage-base <sha>]
+  okstra correction file-size --base <stage base sha> [--head <rev>] [--repo <path>]
 
-Prints the instruction body for one correction-round prompt; pass it to
+`prompt` prints the instruction body for one correction-round prompt; pass it to
 `okstra agent-prompt materialize --instruction` with --dispatch-kind correction-r<N>.
-Findings are read from the run's convergence record. Exit 1 on a refusal.
+Findings are read from the run's convergence record; --stage-base adds the file-size
+findings of `<stage-base>..<base>` (the 400-line limit only). Exit 1 on a refusal.
+
+`file-size` prints one `FILE-SIZE:<path>:401` line per file the stage diff leaves over
+the 400-line limit (blocking) and one `FILE-SIZE-ADVISORY:<path>:301` line per file it
+leaves over only the 300-line target, then `QA-RESULT: PASS|FAIL`; only a limit line
+fails. Exit 1 on FAIL, 2 when git cannot read the range.
 """
 
 
+def _file_size(args: argparse.Namespace) -> int:
+    try:
+        violations = file_size_violations(Path(args.repo), args.base, args.head)
+    except subprocess.CalledProcessError as exc:
+        print(f"error: git: {exc.stderr.decode(errors='replace').strip()}", file=sys.stderr)
+        return 2
+    for violation in violations:
+        print(violation.line())
+    failed = any(v.blocking for v in violations)
+    print(f"QA-RESULT: {'FAIL' if failed else 'PASS'} "
+          f"(file-size limit {FILE_LINE_LIMIT}, target {FILE_LINE_TARGET})")
+    return 1 if failed else 0
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="okstra correction",
@@ -33,9 +56,17 @@ def main(argv: list[str] | None = None) -> int:
     prompt.add_argument("--role", choices=("executor", "verifier"), required=True)
     prompt.add_argument("--base", required=True,
                         help="the stage HEAD before this round")
-    prompt.add_argument("--finding", action="append", default=[], required=True,
+    prompt.add_argument("--finding", action="append", default=[],
                         help="a convergence finding id to fix; repeat for several")
+    prompt.add_argument("--stage-base", default="",
+                        help="the stage base commit; adds the stage diff's file-size limit findings")
+    size = commands.add_parser("file-size", help="check the stage diff against the file-size limit and target")
+    size.add_argument("--base", required=True, help="the stage base commit")
+    size.add_argument("--head", default="HEAD")
+    size.add_argument("--repo", default=".", help="the stage worktree (default: cwd)")
     args = parser.parse_args(argv)
+    if args.command == "file-size":
+        return _file_size(args)
 
     try:
         authority = validated_run_authority(args.run_manifest)
@@ -45,10 +76,18 @@ def main(argv: list[str] | None = None) -> int:
             authority, manifest_field="convergenceStatePath", prefix="convergence",
             label="convergence state",
         )
+        size_violations = [
+            v for v in file_size_violations(Path.cwd(), args.stage_base, args.base)
+            if v.blocking
+        ] if args.stage_base else []
         print(correction_instruction(
             convergence_path=convergence_path, round_number=args.round, role=args.role,
-            base=args.base, finding_ids=args.finding,
+            base=args.base, finding_ids=args.finding, stage_base=args.stage_base,
+            size_violations=size_violations,
         ))
+    except subprocess.CalledProcessError as exc:
+        print(f"error: git: {exc.stderr.decode(errors='replace').strip()}", file=sys.stderr)
+        return 1
     except (CorrectionRoundError, OSError, ValueError) as exc:
         print(f"error: {exc}", file=sys.stderr)
         return 1

package/runtime/python/okstra_ctl/correction_round.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Mapping, Sequence
 
 from .execution_identity import ExecutionManifest
+from .file_size_cap import FILE_LINE_LIMIT, FileSizeViolation
 from .json_boundary import load_owned_object
 
 MAX_CORRECTION_ROUNDS = 2
@@ -101,17 +102,11 @@ def _finding_lines(findings: Sequence[Mapping[str, object]]) -> list[str]:
     return lines
 
 
-def correction_instruction(
-    *, convergence_path: Path, round_number: int, role: str, base: str,
-    finding_ids: Sequence[str],
-) -> str:
-    """The instruction body one correction-round prompt carries, read from the convergence record."""
-    if not 1 <= round_number <= MAX_CORRECTION_ROUNDS:
-        raise CorrectionRoundError(f"--round must be 1..{MAX_CORRECTION_ROUNDS}")
+def _convergence_findings(
+    convergence_path: Path, finding_ids: Sequence[str],
+) -> list[Mapping[str, object]]:
     if not finding_ids:
-        raise CorrectionRoundError("name at least one --finding")
-    if not base.strip():
-        raise CorrectionRoundError("--base is required: the stage HEAD before this round")
+        return []
     record = load_owned_object(convergence_path, artifact="convergence record")
     by_id = {
         str(row.get("findingId")): row for row in record.get("findings") or []
@@ -123,14 +118,40 @@ def correction_instruction(
             f"findings not in {convergence_path.name}: {', '.join(missing)}; "
             f"it holds {', '.join(sorted(by_id)) or 'none'}"
         )
-    findings = [by_id[fid] for fid in finding_ids]
+    return [by_id[fid] for fid in finding_ids]
+
+
+def correction_instruction(
+    *, convergence_path: Path, round_number: int, role: str, base: str,
+    finding_ids: Sequence[str], stage_base: str = "",
+    size_violations: Sequence[FileSizeViolation] = (),
+) -> str:
+    """The instruction body one correction-round prompt carries.
+
+    Verifier findings are read from the convergence record. File-size findings come from
+    `file_size_cap.file_size_violations` over `stage_base..base`, so they need no verifier
+    to have reported them.
+    """
+    if not 1 <= round_number <= MAX_CORRECTION_ROUNDS:
+        raise CorrectionRoundError(f"--round must be 1..{MAX_CORRECTION_ROUNDS}")
+    if not finding_ids and not size_violations:
+        raise CorrectionRoundError(
+            "name at least one --finding, or pass --stage-base for a stage whose diff "
+            "breaks the 400-line file-size limit"
+        )
+    if not base.strip():
+        raise CorrectionRoundError("--base is required: the stage HEAD before this round")
+    findings = _convergence_findings(convergence_path, finding_ids)
     results_dir = convergence_path.parent.parent / "worker-results"
+    stage_base_ref = stage_base.strip() or "<the stage base>"
     header = [
         f"- Convergence record: `{convergence_path}`",
         f"- Verifier results (each finding's suggested fix): `{results_dir}`",
         f"- Stage HEAD before this round: `{base.strip()}`",
+        *([f"- Stage base (file-size limit): `{stage_base.strip()}`"] if stage_base.strip() else []),
         "- Findings:",
         *("  " + line for line in _finding_lines(findings)),
+        *(f"  - `{v.finding_id}` (file-size limit; okstra): {v.line()}" for v in size_violations),
         "",
     ]
     if role == "executor":
@@ -144,6 +165,11 @@ def correction_instruction(
             "dependency, or a schema or migration change is not fixed here: stop and say so.",
             "- Update a test's expected value only where the finding shows the oracle itself is "
             "wrong; never weaken or delete an assertion to make a test pass.",
+            f"- A `FILE-SIZE:` finding is fixed by moving whole responsibilities (a group of "
+            f"functions, a class, a `describe` block) into new files beside the oversized one; "
+            f"those files count as inside this stage. Never compress code or drop comments to "
+            f"meet the number. Done when `okstra correction file-size --base {stage_base_ref}` "
+            f"prints `QA-RESULT: PASS` (limit {FILE_LINE_LIMIT} lines; aim for 300).",
             "- Follow the executor sidecar's TDD, pre-commit diff review and self-check, and "
             "commit with a Conventional Commit whose body names the finding ids.",
             "- Re-run the plan validation commands that cover the fix, and end with a "
@@ -161,6 +187,9 @@ def correction_instruction(
             "the stage was reviewed in the initial round.",
             "- Re-run every plan validation command, as the verifier sidecar's Fix-run "
             "incremental scope requires.",
+            f"- Run `okstra correction file-size --base {stage_base_ref}` against the stage base, "
+            "not this round's base: each `FILE-SIZE:` line it prints is a blocking finding, and each "
+            "`FILE-SIZE-ADVISORY:` line a recommendation.",
             "- Verdict `PASS` when every finding is fixed and no blocking check hits the "
             "correction diff; otherwise `FAIL`, with each remaining or new finding in the "
             "usual format.",

package/runtime/python/okstra_ctl/domain/mcp.py

@@ -0,0 +1,43 @@
+"""provider 어댑터와 핵심 판정이 함께 쓰는 벤더 중립 MCP 목록 값."""
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Literal
+
+McpServerState = Literal["enabled", "disabled", "needs-auth"]
+
+
+@dataclass(frozen=True)
+class VisibleMcpServer:
+    name: str
+    state: McpServerState
+
+
+@dataclass(frozen=True)
+class McpInventory:
+    """``listed`` 가 False 면 목록 자체를 못 얻은 것이라 선언 서버를 ``missing``
+    이 아니라 ``unknown`` 으로 판정한다."""
+
+    listed: bool
+    servers: tuple[VisibleMcpServer, ...] = ()
+    note: str = ""
+
+    @classmethod
+    def unavailable(cls, note: str) -> McpInventory:
+        return cls(listed=False, note=note)
+
+
+McpInventoryParser = Callable[[str], McpInventory]
+
+
+@dataclass(frozen=True)
+class McpInventoryProbe:
+    """추론 호출 없이 MCP 서버를 나열하는 명령과 그 출력 파서.
+
+    실행은 어댑터가 아니라 핵심 코드가 맡아 모든 provider 에 같은 타임아웃과
+    cwd(프로젝트 루트)를 적용한다.
+    """
+
+    argv: tuple[str, ...]
+    parse: McpInventoryParser

package/runtime/python/okstra_ctl/domain/provider.py

@@ -5,6 +5,7 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Literal, Mapping, Optional, Protocol
 
+from .mcp import McpInventoryProbe
 from .role import RoleCatalogError, normalize_role, ROLE_CATALOG
 from .worker_exec import WorkerWriteCapability
 
@@ -195,6 +196,7 @@ class ProviderSpec:
     exec_strategy: Optional["ExecutionStrategy"] = None
     execution_normalizer: Optional[ExecutionNormalizer] = None
     served_model_normalizer: ServedModelNormalizer = unavailable_served_model
+    mcp_inventory: Optional[McpInventoryProbe] = None
     _legacy_role_restriction: frozenset[str] = field(
         init=False,
         repr=False,

package/runtime/python/okstra_ctl/domain/wizard/interaction.py

@@ -33,7 +33,13 @@ class WizardPrompt:
 
 @dataclass(frozen=True)
 class AnswerProtocol:
-    kind: Literal["exact-value", "numbered", "group-json", "numbered-group-json"]
+    kind: Literal[
+        "exact-value",
+        "numbered",
+        "selected-labels",
+        "group-json",
+        "numbered-group-json",
+    ]
     multi: bool = False
 
 
@@ -120,6 +126,76 @@ def _normalize_numbered_answer(
     )
 
 
+_LABEL_SEPARATOR = ", "
+
+
+def labels_decode_uniquely(labels: tuple[str, ...]) -> bool:
+    """이 라벨들을 `", "` 로 이은 어떤 선택이든 한 가지로만 되쪼개지는가.
+
+    네이티브 다중 선택 호스트는 고른 라벨을 `", "` 로 이어 돌려주는데 라벨 자체도
+    `", "` 를 품을 수 있다. 선택 문자열은 `label + ", "` 낱말의 연접이므로 그
+    낱말 집합에 대한 Sardinas-Patterson 유일 복호 판정이다.
+    """
+    words = {label + _LABEL_SEPARATOR for label in labels}
+    if len(words) != len(labels):
+        return False
+
+    def dangling(prefixes: set[str], strings: set[str]) -> set[str]:
+        return {
+            string[len(prefix):]
+            for prefix in prefixes
+            for string in strings
+            if string != prefix and string.startswith(prefix)
+        }
+
+    seen: set[str] = set()
+    suffixes = dangling(words, words)
+    while suffixes:
+        if suffixes & words:
+            return False
+        seen |= suffixes
+        suffixes = (dangling(words, suffixes) | dangling(suffixes, words)) - seen
+    return True
+
+
+def _normalize_selected_labels(prompt: WizardPrompt, answer: str) -> str:
+    text = answer or ""
+    if not text.strip():
+        return ""
+    target = text + _LABEL_SEPARATOR
+    words = tuple(option.label + _LABEL_SEPARATOR for option in prompt.options)
+    # ways[i] 는 target[i:] 를 쪼개는 방법 수(2 에서 멈춤), first[i] 는 방법이
+    # 하나일 때 그 첫 옵션 위치다.
+    ways = [0] * len(target) + [1]
+    first = [-1] * (len(target) + 1)
+    for start in range(len(target) - 1, -1, -1):
+        for index, word in enumerate(words):
+            if target.startswith(word, start) and ways[start + len(word)]:
+                ways[start] = min(2, ways[start] + ways[start + len(word)])
+                first[start] = index
+    if ways[0] == 0:
+        values = {option.value for option in prompt.options}
+        # 라벨 대신 값 CSV 를 낸 제출(직접 CLI 입력, 값으로 바꿔 내는 리드)도 받는다.
+        if all(item.strip() in values for item in text.split(",")):
+            return ",".join(item.strip() for item in text.split(","))
+        raise WizardAnswerError(
+            f"multi-select answer is not a {_LABEL_SEPARATOR!r}-joined list "
+            f"of option labels: {text}"
+        )
+    if ways[0] > 1:
+        raise WizardAnswerError(f"multi-select answer labels are ambiguous: {text}")
+    selected: set[int] = set()
+    position = 0
+    while position < len(target):
+        selected.add(first[position])
+        position += len(words[first[position]])
+    return ",".join(
+        option.value
+        for index, option in enumerate(prompt.options)
+        if index in selected
+    )
+
+
 def _group_answers(answer: str) -> dict[str, object]:
     try:
         answers = json.loads(answer or "{}")
@@ -137,19 +213,22 @@ def _normalize_group_answer(
     numbered: bool,
 ) -> str:
     answers = _group_answers(answer)
-    if not numbered:
-        return json.dumps(answers, ensure_ascii=False, separators=(",", ":"))
     questions = {question.step: question for question in prompt.questions}
     normalized = dict(answers)
     for step, raw_answer in answers.items():
         question = questions.get(step)
         if question is None:
             continue
-        normalized[step] = _normalize_numbered_answer(
-            question,
-            str(raw_answer or ""),
-            multi=question.multi,
-        )
+        if numbered:
+            normalized[step] = _normalize_numbered_answer(
+                question,
+                str(raw_answer or ""),
+                multi=question.multi,
+            )
+        elif question.multi:
+            normalized[step] = _normalize_selected_labels(
+                question, str(raw_answer or "")
+            )
     return json.dumps(normalized, ensure_ascii=False, separators=(",", ":"))
 
 
@@ -162,6 +241,8 @@ def normalize_planned_answer(
         return answer
     if protocol.kind == "numbered":
         return _normalize_numbered_answer(prompt, answer, multi=protocol.multi)
+    if protocol.kind == "selected-labels":
+        return _normalize_selected_labels(prompt, answer)
     if protocol.kind in {"group-json", "numbered-group-json"}:
         return _normalize_group_answer(
             prompt,