okstra 0.206.0 → 0.207.0

package/runtime/python/okstra_ctl/report_synthesis_packet.py

@@ -15,22 +15,14 @@ from okstra_token_usage.blocks import accounting_workers
 
 from .analysis_packet import reference_source_extracts
 from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
-from .implementation_options import (
-    CANDIDATE_COMPARISON_ROUTING,
-    EVALUATION_CRITERIA,
-    MAX_CRITERION_VALUE,
-    MAX_RANKED_OPTIONS,
-    MAX_RAW_CANDIDATES_PER_ANALYSER,
-    MIN_CRITERION_VALUE,
-    MIN_FEASIBLE_VOTES,
-    NO_VALID_OPTIONS_ROUTING,
+from .phases.implementation_option_selection.authoring import (
+    requirement_instructions as selection_requirement_instructions,
 )
 from .report_narrative import writer_owned_data, writer_owned_schema
 from .schema_excerpt import build_schema_excerpt
 from .stage_ledger import build_stage_ledger
 from .scope_provenance import brief_end_state_id_sequence
 
-from .exact_coverage import COVERAGE_VERDICT_PRECEDENCE
 from .final_report_schema import follow_up_task_rules, task_block_rules, verdict_token_rule
 from .report_contract import TASK_TYPE_DATA_PROPERTY
 from .report_markdown import humanise
@@ -251,70 +243,9 @@ class ReportSynthesisPacket:
             return self._planning_requirement_instructions()
         if self.task_type != "implementation-option-selection":
             return []
-        criteria = ", ".join(f"`{item}`" for item in EVALUATION_CRITERIA)
-        requirement_ids = ", ".join(
-            f"`{item}`" for item in self.original_requirement_ids
-        )
-        analysers = ", ".join(
-            f"`{item}`" for item in self.participating_analysers
+        return selection_requirement_instructions(
+            self.original_requirement_ids, self.participating_analysers,
         )
-        return [
-            f"Original requirement ids, in order: {requirement_ids}.",
-            f"Participating analysers: {analysers}.",
-            f"Evaluation criteria, in exact order: {criteria}.",
-            "Every `rankedOptions` and `candidateAudit` row must contain one "
-            "`requirementCoverage` row per original requirement id and one "
-            "`criterionScores` row per evaluation criterion. Weights and scores "
-            f"are integers from {MIN_CRITERION_VALUE} through {MAX_CRITERION_VALUE}; "
-            "`weightedScore` is the recalculated weighted mean.",
-            "`proposedBy` names exactly one participating analyser id, never a "
-            "list. Counting `rankedOptions` and `candidateAudit` together, each "
-            f"analyser may propose at most {MAX_RAW_CANDIDATES_PER_ANALYSER} raw "
-            "candidates and the run may hold at most "
-            f"{MAX_RAW_CANDIDATES_PER_ANALYSER} times the analyser count.",
-            "`coverageSummary` is recalculated from the row's `requirementCoverage` "
-            "statuses and `scopeCommitments`, and every field must equal the "
-            "recalculation: `totalCount` = number of original requirement ids; "
-            "`coveredCount` = rows with status `covered`; `coveragePercent` = "
-            "round(coveredCount / totalCount * 100, 2); `unmappedCommitments` = "
-            "commitment ids whose `requirementIds` is empty or names an id outside "
-            "the original set; `scopePrecisionPercent` = round((commitments - "
-            "unmapped) / commitments * 100, 2); `contradictedRequirements` = "
-            "original ids with status `contradicted`, in original order; "
-            "`coverageVerdict` = the first that applies of "
-            + ", ".join(f"`{verdict}`" for verdict in COVERAGE_VERDICT_PRECEDENCE)
-            + " (any contradicted; coveredCount below totalCount; any unmapped; "
-            "otherwise).",
-            "A ranked option is valid only when every participating analyser "
-            "supplied one feasibility vote, at least "
-            f"{MIN_FEASIBLE_VOTES} votes are `feasible`, and both `safetyBlockers` "
-            "and `unresolvedFeasibilityFacts` are empty.",
-            ("Classify each `unresolvedFeasibilityFacts` entry with `resolutionKind`: "
-            "`user-decision` requires nonempty `clarificationRefs` linking that fact "
-            "to actual C-NNN records, including answered records; `technical-verification` "
-            "requires no user question. Preserve the fact, whyItMatters, and evidence. "
-            "Historical unclassified facts remain readable but require classification "
-            "before blocked report reassembly. Saving does not lift blocked routing."),
-            ("After a linked decision is answered, preserve its disposition and selected "
-            "value. Update humanSummary.actions, verdictCard.nextStep, and selection "
-            "guidance to name remaining technical verification separately from unanswered "
-            "user decisions; never reopen an answered question to permit saving."),
-            "Each `feasibilityVotes` row states that analyser's own verdict, "
-            "rationale, and strongest counterevidence as its result gives them. "
-            "Two non-`uncertain` votes with identical rationale and "
-            "counterevidence are rejected as one worker's text copied under "
-            "another's name.",
-            f"Rank at most {MAX_RANKED_OPTIONS} valid options by descending "
-            "`requirement-fit`, `correctness-risk`, `architecture-fit`, "
-            "`weightedScore`, then id. With valid options set routing to "
-            f"`{CANDIDATE_COMPARISON_ROUTING}`; without a valid option use "
-            f"`{NO_VALID_OPTIONS_ROUTING}`.",
-            "In `candidate-comparison`, keep `preselectedDirection` null and do "
-            "not route directly to `implementation-planning`. In "
-            "`preselected-validation`, emit exactly one validated option, an empty "
-            "`candidateAudit`, a cited `preselectedDirection`, and routing "
-            "`implementation-planning`.",
-        ]
 
     def _planning_requirement_instructions(self) -> list[str]:
         """계획 저작 계약에 브리프 요구사항 id 순서를 박아 넣는다.

package/runtime/python/okstra_ctl/report_validation_identity.py

@@ -0,0 +1,38 @@
+"""보고서 검증 시 파일 이름에서 실행 식별자를 읽는다."""
+
+from pathlib import Path
+import re
+
+_REPORT_BASENAME_SEQ_RE = re.compile(r"-(?P<seq>\d{3})(?:\.data)?\.(?:md|json)$")
+
+
+_REPORT_BASENAME_TASK_TYPE_RE = re.compile(
+    r"^final-report-(?P<task_type>[a-z][a-z-]*?)-\d{3}(?:\.data)?\.(?:md|json)$"
+)
+
+
+def _report_run_seq(report_path: Path) -> str | None:
+    """This run's seq, read off `final-report-<task-type>-<seq>.md`. ``None``
+    when the name does not carry one, so callers fall back to not filtering
+    rather than silently checking nothing."""
+    match = _REPORT_BASENAME_SEQ_RE.search(report_path.name)
+    return match.group("seq") if match else None
+
+
+def _report_task_type(report_path: Path) -> str:
+    """This run's task type, read off `final-report-<task-type>-<seq>`.
+
+    The report's own `header.taskType` is the first source, but it is not
+    always reachable. `report_narrative._allowed_top_level()` has no `header` —
+    it is not a writer-owned block — so a gate scored from a narrative, which is
+    the only input a report-contract-3.0 run has before assembly, carries no
+    task type at all. Globbing with an empty one matched nothing and reported
+    every verdict as unbacked under a `runs//worker-results/` path.
+
+    The filename carries it in every caller: the full-run path passes the report
+    itself, and `_report_path_for_state` builds the same canonical name from the
+    state file. Returns `""` when the name does not carry one, so a caller can
+    tell "not resolvable" from a real task type.
+    """
+    match = _REPORT_BASENAME_TASK_TYPE_RE.match(report_path.name)
+    return match.group("task_type") if match else ""

package/runtime/python/okstra_ctl/report_views.py

@@ -41,7 +41,7 @@ from .user_response_values import (  # noqa: F401 — 재노출(값 타입은 le
 )
 from .final_report_paths import final_report_data_path
 from .json_boundary import JsonBoundaryError, load_owned_object
-from .report_html.view_models.implementation_planning import (
+from .plan_approval import (
     PlanApprovalState,
     plan_approval_state,
     resolve_recommended_option,