okstra 0.152.0 → 0.154.0

package/runtime/templates/reports/schedule.template.md

@@ -89,12 +89,12 @@ _none_
 Day:            1    5    10   15   20   25   30
                 |    |    |    |    |    |    |
 Phase 1
-  <TASK-ID> (<size>)           ██████          ! crit
-  <TASK-ID> (<size>)                 ████████
+  <TASK-ID>/S<stage-number>    ██████          ! crit days=<lower>~<upper>
+  <TASK-ID>/S<stage-number>          ████████  days=<lower>~<upper>
 Phase 2
-  <TASK-ID> (<size>)                         ██████░░  est
+  <TASK-ID>/S<stage-number>                  ██████░░  est days=<lower>~<upper>
 Phase 3
-  <TASK-ID> (<size>)                                  ████  (after <TASK-ID>)
+  <TASK-ID>/S<stage-number>                           ████  (after <TASK-ID>/S<stage-number>) days=<lower>~<upper>
 ```
 
 > The axis is in **relative day-counts** (Day 1 = Phase 1 start). Legend: `! crit` = critical path, `est` = estimated allocation, `█` = confirmed span, `░` = upper-bound / uncertain span.
@@ -110,7 +110,7 @@ Phase 3
 | **Category** | <category> |
 | **Priority** | <P0~P3> |
 | **Effort** | **<S/M/L/XL>** (<scope summary>) |
-| **Status** | <workStatus + currentPhase summary> |
+| **Status** | <taskType> / <currentPhase> |
 | **Risk** | <risk> |
 | **Scope** | <files / repos summary> |
 | **Repo** | <repos> |
@@ -121,9 +121,10 @@ Phase 3
 
 **Work Breakdown**:
 
-| Step | File | Action | Detail |
-|------|------|--------|--------|
-| 1 | <path> | CREATE/MODIFY/VERIFY | <detail> |
+| Stage | Title | Steps | Depends On | Days |
+|---:|---|---:|---|---:|
+| 2 | Build adapter | 3 | 1 (done) | 2.0 ~ 3.0 |
+| 3 | Wire consumer | 2 | 2 | 1.0 ~ 2.0 |
 
 **Verification Commands**:
 ```bash
@@ -183,4 +184,3 @@ _none_ <!-- or repeat per-task block -->
 |------|-------------|
 | FC-5 | Missing payment gateway timeout handling |
 -->
-

package/runtime/validators/detect_self_mock.py

@@ -41,8 +41,10 @@ redirecting ``--waivers`` at a self-authored file blocks instead of passing.
 from __future__ import annotations
 
 import argparse
+import io
 import json
 import sys
+import tokenize
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -91,16 +93,39 @@ def scannable_files(paths: list[Path]) -> list[Path]:
     return [p for p in paths if is_scannable(p)]
 
 
+def _mask_python_non_code(text: str) -> str:
+    """Blank Python strings and comments without moving any match positions."""
+    chars = list(text)
+    line_offsets = [0]
+    for line in text.splitlines(keepends=True):
+        line_offsets.append(line_offsets[-1] + len(line))
+    try:
+        tokens = tokenize.generate_tokens(io.StringIO(text).readline)
+        for token in tokens:
+            if token.type not in {tokenize.STRING, tokenize.COMMENT}:
+                continue
+            start = line_offsets[token.start[0] - 1] + token.start[1]
+            end = line_offsets[token.end[0] - 1] + token.end[1]
+            for index in range(start, end):
+                if chars[index] not in "\r\n":
+                    chars[index] = " "
+    except (tokenize.TokenError, IndentationError, SyntaxError):
+        # Broken source is scanned conservatively so a syntax error cannot hide a hit.
+        return text
+    return "".join(chars)
+
+
 def scan_files(paths: list[Path]) -> list[dict]:
     """Return one hit dict ``{file, line, signal}`` per signal match."""
     hits: list[dict] = []
     for p in scannable_files(paths):
         lang = EXT_TO_LANG[p.suffix]
         text = p.read_text(encoding="utf-8", errors="replace")
+        scan_text = _mask_python_non_code(text) if lang == "python" else text
         file_hits: list[dict] = []
         for sig in SIGNALS.get(lang, []):
-            for m in sig.pattern.finditer(text):
-                line = text[: m.start()].count("\n") + 1
+            for m in sig.pattern.finditer(scan_text):
+                line = scan_text[: m.start()].count("\n") + 1
                 file_hits.append({"file": str(p), "line": line, "signal": sig.name})
         hits.extend(sorted(file_hits, key=lambda h: (h["line"], h["signal"])))
     return hits

package/runtime/validators/validate-implementation-plan-stages.py

@@ -20,8 +20,13 @@ for _ssot_dir in (_VALIDATORS_DIR.parent / "scripts", _VALIDATORS_DIR.parent / "
         sys.path.insert(0, str(_ssot_dir))
 
 from okstra_ctl.md_table import split_pipe_row  # noqa: E402
+from okstra_ctl.stage_map import (  # noqa: E402
+    STAGE_MAP_HEADING,
+    StageMapError,
+    StageMapStage,
+    parse_stage_map_text,
+)
 
-STAGE_MAP_HEADING = re.compile(r"^##\s+5\.5\s+Stage\s+Map\b", re.M)
 HARD_STEP_CAP = 8
 REQUIRED_SUBSECTIONS = (
     "Carry-In",
@@ -36,15 +41,6 @@ EXIT_CONTRACT_HEADING = re.compile(r"^###\s+Stage Exit Contract\b", re.M)
 PATH_TOKEN = re.compile(r"(?:[\w.@-]+/)+[\w.@-]+")
 
 
-@dataclass
-class StageMeta:
-    stage_number: int
-    title: str
-    depends_on: List[int]
-    step_count: int
-    exit_contract_summary: str
-
-
 @dataclass
 class ValidationError:
     code: str   # S1..S11
@@ -60,11 +56,7 @@ def _check_stage_map_present(text: str) -> List[ValidationError]:
 
 
 def _parse_depends_on_cell(raw: str) -> List[int] | None:
-    """Stage numbers in a `depends-on` cell; None when the cell is unparseable.
-
-    Schema v2 keeps the same literal cell text in `stageMap[].dependsOn`, so
-    both the Markdown scan and the data scan read it through here.
-    """
+    """Stage numbers from schema-v2 `stageMap[].dependsOn`."""
     value = raw.strip()
     if value in ("(none)", ""):
         return []
@@ -74,7 +66,9 @@ def _parse_depends_on_cell(raw: str) -> List[int] | None:
         return None
 
 
-def _stage_numbers_monotonic(stages: List[StageMeta]) -> List[ValidationError]:
+def _stage_numbers_monotonic(
+    stages: List[StageMapStage],
+) -> List[ValidationError]:
     return [
         ValidationError("S2", r.stage_number,
             f"stage numbers must be 1..N monotonic, got {r.stage_number} at row {i}")
@@ -82,43 +76,6 @@ def _stage_numbers_monotonic(stages: List[StageMeta]) -> List[ValidationError]:
         if r.stage_number != i
     ]
 
-
-def _parse_stage_map(text: str) -> Tuple[List[StageMeta], List[ValidationError]]:
-    m = STAGE_MAP_HEADING.search(text)
-    if not m:
-        return [], []   # S1 already reported
-    body = text[m.end():]
-    rows = []
-    for line in body.splitlines():
-        if line.startswith("##"):
-            break
-        if not line.strip().startswith("|"):
-            continue
-        cells = split_pipe_row(line)
-        if len(cells) != 5:
-            continue
-        # skip header and separator rows (all-dash of any length is covered by set check)
-        if cells[0] == "stage" or set(cells[0]) <= set("-"):
-            continue
-        try:
-            n = int(cells[0])
-        except ValueError:
-            continue
-        depends = _parse_depends_on_cell(cells[2])
-        if depends is None:
-            # 비정수 depends_on 셀 → 행 skip (비정수 stage_number 와 동일). raw
-            # ValueError 를 흘리면 _stage_map_reject_detail·handoff 의 except
-            # PrepareError 를 우회해 traceback 으로 죽으므로, 누락된 행을 하류
-            # S2(비단조) 검사가 잡게 한다.
-            continue
-        try:
-            step_count = int(cells[3])
-        except ValueError:
-            step_count = -1
-        rows.append(StageMeta(n, cells[1], depends, step_count, cells[4]))
-    return rows, _stage_numbers_monotonic(rows)
-
-
 def _slice_stage_section(text: str, stage_number: int) -> str:
     """Return the body of `## 5.5.<n> Stage <n>:` up to the next stage heading."""
     start_m = re.search(
@@ -165,7 +122,7 @@ def _count_effective_steps(section: str) -> int:
     return len(_effective_step_rows(section))
 
 
-def _check_each_stage_section(text: str, stages: List[StageMeta]) -> List[ValidationError]:
+def _check_each_stage_section(text: str, stages: List[StageMapStage]) -> List[ValidationError]:
     errs: List[ValidationError] = []
     for s in stages:
         if not re.search(
@@ -227,7 +184,7 @@ def _exemption_reason_allowed(section: str) -> bool:
     return any(cat in reason for cat in TDD_EXEMPTION_ALLOWED)
 
 
-def _check_slice_tdd(text: str, stages: List[StageMeta]) -> List[ValidationError]:
+def _check_slice_tdd(text: str, stages: List[StageMapStage]) -> List[ValidationError]:
     """S10: each stage declares a vertical slice and follows RED→GREEN ordering.
 
     S10a — `Slice value:` line with a non-empty value.
@@ -305,7 +262,7 @@ def _check_red_green_steps(section: str, stage_number: int) -> List[ValidationEr
 
 
 def _check_conformance_declaration(
-    text: str, stages: List[StageMeta]
+    text: str, stages: List[StageMapStage]
 ) -> List[ValidationError]:
     """S11: 각 stage 는 conformance 검증을 선언하거나 명시적으로 면제한다.
 
@@ -326,7 +283,7 @@ def _check_conformance_declaration(
     return errs
 
 
-def _check_depends_on(stages: List[StageMeta]) -> List[ValidationError]:
+def _check_depends_on(stages: List[StageMapStage]) -> List[ValidationError]:
     errs: List[ValidationError] = []
     valid = {s.stage_number for s in stages}
     for s in stages:
@@ -387,7 +344,9 @@ def _report_shared_parallel_files(files: dict) -> List[ValidationError]:
     return errs
 
 
-def _check_parallel_safety(text: str, stages: List[StageMeta]) -> List[ValidationError]:
+def _check_parallel_safety(
+    text: str, stages: List[StageMapStage],
+) -> List[ValidationError]:
     """S9: two `depends-on (none)` stages must not predict the same file —
     otherwise two parallel implementation runs would edit it concurrently."""
     return _report_shared_parallel_files({
@@ -411,8 +370,10 @@ def collect_validation_errors(text: str) -> List[ValidationError]:
         return present
 
     errors: List[ValidationError] = []
-    stages, s2_errs = _parse_stage_map(text)
-    errors.extend(s2_errs)
+    try:
+        stages = parse_stage_map_text(text)
+    except StageMapError as exc:
+        return [ValidationError("S2", 0, exc.reason)]
     if stages:
         errors.extend(_check_each_stage_section(text, stages))
         errors.extend(_check_slice_tdd(text, stages))
@@ -424,7 +385,7 @@ def collect_validation_errors(text: str) -> List[ValidationError]:
 
 def _data_stage_metas(
     stage_map: List[dict],
-) -> Tuple[List[StageMeta], List[ValidationError]]:
+) -> Tuple[List[StageMapStage], List[ValidationError]]:
     rows = []
     for row in stage_map:
         if not isinstance(row, dict) or not isinstance(row.get("stage"), int):
@@ -432,7 +393,7 @@ def _data_stage_metas(
         depends = _parse_depends_on_cell(str(row.get("dependsOn") or ""))
         if depends is None:
             continue
-        rows.append(StageMeta(
+        rows.append(StageMapStage(
             row["stage"],
             str(row.get("title") or ""),
             depends,
@@ -486,7 +447,7 @@ def _check_data_slice_tdd(stage: dict) -> List[ValidationError]:
 
 
 def _check_data_step_counts(
-    stage_map: List[StageMeta], stages: List[dict]
+    stage_map: List[StageMapStage], stages: List[dict]
 ) -> List[ValidationError]:
     """The Stage Map row is the plan's own index of its stage body. A row
     claiming a step count the body does not have makes the map unusable for

package/runtime/validators/validate-run.py

@@ -3249,6 +3249,10 @@ def validate_final_report_data(
             (data.get("implementationPlanning") or {}).get("planBodyVerification") or {}
         ):
             print(f"validate-run: warning: {warning}", file=sys.stderr)
+        for warning in _detect_uniform_verifier(
+            (data.get("implementationPlanning") or {}).get("planBodyVerification") or {}
+        ):
+            print(f"validate-run: warning: {warning}", file=sys.stderr)
         for warning in _detect_unmapped_incremental_fallback(data, report_path):
             print(f"validate-run: warning: {warning}", file=sys.stderr)
         for warning in _detect_missing_dependency_precondition(
@@ -3259,6 +3263,7 @@ def validate_final_report_data(
         _validate_self_fix_grouping(data, failures)
         _validate_clarification_evidence_note(data, failures)
         _validate_plan_body_verdict_provenance(data, report_path, failures)
+        _validate_reverify_result_addresses_prior_dissent(data, report_path, failures)
         _validate_aborted_gate_has_clarification(data, failures)
         _validate_round_recorded_verdicts(data, failures)
         _validate_verdicts_match_current_subjects(data, failures)
@@ -5048,6 +5053,111 @@ def _validate_plan_body_verdict_provenance(
         )
 
 
+_UNIFORM_VERIFIER_MIN_ITEMS = 5
+
+
+def _detect_uniform_verifier(pbv: dict) -> list[str]:
+    """Verifiers whose every vote in the round was the same verdict.
+
+    `participatingAnalysers` counts whether a worker voted, not whether the
+    votes carried information. A verifier that answers AGREE to every item is
+    counted as a third opinion while contributing no refutation signal, so the
+    report reads as a three-way cross-check backed by two. (fontsninja-nlpvibe
+    `nlpvibe-vs-fontradar-baseline` seq 001: 63/63 AGREE off six inspected
+    evidence paths, on a round where the two other analysers jointly refuted a
+    real defect.)
+
+    Advisory only. A unanimous round is a legitimate outcome, and any ratio
+    strict enough to catch a rubber stamp also fails honest agreement, so this
+    reports the counts and leaves the judgement to the reader.
+    """
+    items = pbv.get("planItems") if isinstance(pbv, dict) else None
+    if not isinstance(items, list):
+        return []
+    verdicts_by_worker: dict[str, set[str]] = {}
+    counts: dict[str, int] = {}
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        for verdict in item.get("verdicts") or []:
+            if not isinstance(verdict, dict):
+                continue
+            worker = str(verdict.get("worker") or "").strip()
+            value = str(verdict.get("verdict") or "").strip()
+            if not worker or not value or value == "verification-error":
+                continue
+            verdicts_by_worker.setdefault(worker, set()).add(value)
+            counts[worker] = counts.get(worker, 0) + 1
+    warnings = []
+    for worker in sorted(verdicts_by_worker):
+        distinct = verdicts_by_worker[worker]
+        total = counts[worker]
+        if len(distinct) != 1 or total < _UNIFORM_VERIFIER_MIN_ITEMS:
+            continue
+        warnings.append(
+            f"plan-body verification: {worker} returned `{next(iter(distinct))}` "
+            f"for all {total} items it voted on, so this round's refutation "
+            "signal came from its peers alone. Confirm the worker actually "
+            "opened the cited evidence (its `-audit-` sidecar lists what it "
+            "read) before reading the gate as a full cross-check."
+        )
+    return warnings
+
+
+_PRIOR_DISSENT_ANCHOR = "**Prior dissent**"
+_PLAN_VERIFY_ROUND_RE = re.compile(r"-plan-verify-r(?P<round>\d+)-")
+
+
+def _plan_verify_round_number(file_name: str) -> int | None:
+    match = _PLAN_VERIFY_ROUND_RE.search(file_name)
+    return int(match.group("round")) if match else None
+
+
+def _validate_reverify_result_addresses_prior_dissent(
+    data: dict,
+    report_path: Path,
+    failures: list[str],
+) -> None:
+    """A round 2+ plan-body verdict must engage the dissent it re-verifies.
+
+    The self-fix loop re-dispatches the same workers against a corrected plan,
+    but nothing carried the previous round's objection into the new prompt. The
+    worker that objected then restates its verdict unchanged and its peers
+    re-judge from nothing, so the loop spends its whole `selfFixMaxRounds`
+    budget re-deriving one split instead of settling it. (fontsninja-nlpvibe
+    `nlpvibe-vs-fontradar-baseline` seq 001: three self-fix rounds to
+    `max-rounds-reached`, gate still `blocked-by-disagreement`, codex holding
+    every DISAGREE it opened.)
+    """
+    worker_results_dir = report_path.parent.parent / "worker-results"
+    if not worker_results_dir.is_dir():
+        return
+    task_type = str((data.get("header") or {}).get("taskType") or "")
+    seq = _report_run_seq(report_path)
+    pattern = f"*-plan-verify-r*-{task_type}-{seq or '*'}.md"
+    silent = []
+    for path in sorted(worker_results_dir.glob(pattern)):
+        if "-audit-plan-verify-r" in path.name:
+            continue
+        round_number = _plan_verify_round_number(path.name)
+        if round_number is None or round_number < 2:
+            continue
+        body = path.read_text(encoding="utf-8", errors="replace")
+        if _PRIOR_DISSENT_ANCHOR not in body:
+            silent.append(path.name)
+    if silent:
+        failures.append(
+            "plan-body re-verification: "
+            f"{silent} carry no `{_PRIOR_DISSENT_ANCHOR}` line. A round 2+ "
+            "verdict exists to settle the previous round's objection, so the "
+            "prompt MUST carry that dissent forward and the worker MUST answer "
+            "whether the correction resolved it. Without it the objecting "
+            "worker repeats its verdict and its peers judge from nothing, and "
+            "the self-fix budget drains on the same split "
+            '(plan-body-verification.md §"Re-verification rounds (round 2+)").'
+        )
+
+
 def _validate_plan_item_extraction_completeness(
     data: dict,
     failures: list[str],

package/runtime/validators/validate-schedule.py

@@ -5,10 +5,12 @@ defined in skills/okstra-schedule-gen/SKILL.md.
 
 Usage:
     python3 validators/validate-schedule.py <path-to-schedule.md>
+    python3 validators/validate-schedule.py <path-to-schedule.md> \
+        --selection-json <selection.json>
 
-Exits 0 if compliant, 1 with a list of violations otherwise. Intended to be
-called by the okstra-schedule-gen skill (self-validation step) and by humans /
-hooks before committing a schedule.
+Exits 0 if compliant, 1 with a list of violations, or 2 for invalid arguments.
+Intended to be called by the okstra-schedule-gen skill (self-validation step)
+and by humans / hooks before committing a schedule.
 """
 
 from __future__ import annotations
@@ -25,6 +27,11 @@ for _ssot_dir in (_VALIDATORS_DIR.parent / "scripts", _VALIDATORS_DIR.parent / "
         sys.path.insert(0, str(_ssot_dir))
 
 from okstra_ctl.md_table import split_pipe_row  # noqa: E402
+from okstra_ctl.schedule_semantics import (  # noqa: E402
+    ScheduleSemanticError,
+    parse_effort_ranges,
+    validate_schedule_semantics,
+)
 
 REQUIRED_SECTIONS_IN_ORDER: list[str] = [
     "## At a Glance",
@@ -142,12 +149,31 @@ DECISION_ITEM_ALLOWLIST = set()  # nothing legitimate matches this shape
 MILESTONE_RE = re.compile(r"\bM(\d+)\b")
 
 
-def validate(path: Path) -> list[str]:
+def _outside_fenced_lines(text: str) -> list[str]:
+    visible: list[str] = []
+    fence_marker = ""
+    for line in text.splitlines():
+        stripped = line.lstrip()
+        marker = stripped[:3] if stripped.startswith(("```", "~~~")) else ""
+        if fence_marker:
+            visible.append("")
+            if marker == fence_marker:
+                fence_marker = ""
+        elif marker:
+            fence_marker = marker
+            visible.append("")
+        else:
+            visible.append(line)
+    return visible
+
+
+def _validate_format(path: Path) -> list[str]:
     if not path.exists():
         return [f"file not found: {path}"]
 
     text = path.read_text(encoding="utf-8")
     lines = text.splitlines()
+    visible_lines = _outside_fenced_lines(text)
     violations: list[str] = []
 
     # 1. Title must end with "— Work Schedule"
@@ -172,7 +198,7 @@ def validate(path: Path) -> list[str]:
     #    Phase 1: Critical Fixes.
     section_positions: dict[str, int] = {}
     optional_positions: dict[str, int] = {}
-    for idx, line in enumerate(lines):
+    for idx, line in enumerate(visible_lines):
         stripped = line.rstrip()
         if stripped in REQUIRED_SECTIONS_IN_ORDER and stripped not in section_positions:
             section_positions[stripped] = idx
@@ -186,6 +212,14 @@ def validate(path: Path) -> list[str]:
     for s in missing:
         violations.append(f"missing required section: {s!r}")
 
+    for authority in ("## At a Glance", REQUIRED_EXEC_SUMMARY_SUBSECTION):
+        count = sum(line.rstrip() == authority for line in visible_lines)
+        if count > 1:
+            violations.append(
+                f"semantic authority {authority!r} must appear exactly once; "
+                f"found {count}"
+            )
+
     if not missing:
         ordered_actual = sorted(section_positions, key=lambda s: section_positions[s])
         if ordered_actual != REQUIRED_SECTIONS_IN_ORDER:
@@ -206,10 +240,19 @@ def validate(path: Path) -> list[str]:
                     "'## Task Dependency Graph' and '## Phase 1: Critical Fixes'"
                 )
     # 4. Executive Summary subsection
-    if REQUIRED_EXEC_SUMMARY_SUBSECTION not in text:
+    effort_heading_count = sum(
+        line.rstrip() == REQUIRED_EXEC_SUMMARY_SUBSECTION
+        for line in visible_lines
+    )
+    if effort_heading_count == 0:
         violations.append(
             f"missing subsection {REQUIRED_EXEC_SUMMARY_SUBSECTION!r} inside Executive Summary"
         )
+    elif effort_heading_count == 1:
+        try:
+            parse_effort_ranges(text)
+        except ScheduleSemanticError as exc:
+            violations.append(str(exc))
 
     # 5. Forbidden translated/extra headings
     for match in FORBIDDEN_HEADINGS_RE.finditer(text):
@@ -503,6 +546,16 @@ def validate(path: Path) -> list[str]:
     return violations
 
 
+def validate(
+    path: Path, selection_path: Path | None = None,
+) -> list[str]:
+    violations = _validate_format(path)
+    if violations or selection_path is None:
+        return violations
+    text = path.read_text(encoding="utf-8")
+    return violations + validate_schedule_semantics(text, selection_path)
+
+
 def _strip_code_fences(text: str) -> str:
     """Remove ``` fenced blocks so opaque-id regex doesn't false-positive
     on shell commands, file paths, etc."""
@@ -654,11 +707,26 @@ def _check_self_contained_identifiers(text: str, lines: list[str],
 
 
 def main(argv: list[str]) -> int:
-    if len(argv) != 2:
-        print(f"usage: {argv[0]} <path-to-schedule.md>", file=sys.stderr)
+    usage = (
+        f"usage: {argv[0]} <path-to-schedule.md> "
+        "[--selection-json <selection.json>]"
+    )
+    args = argv[1:]
+    if len(args) == 1 and not args[0].startswith("-"):
+        path = Path(args[0])
+        selection_path = None
+    elif (
+        len(args) == 3
+        and args[1] == "--selection-json"
+        and not args[0].startswith("-")
+        and not args[2].startswith("-")
+    ):
+        path = Path(args[0])
+        selection_path = Path(args[2])
+    else:
+        print(usage, file=sys.stderr)
         return 2
-    path = Path(argv[1])
-    violations = validate(path)
+    violations = validate(path, selection_path)
     if not violations:
         print(f"OK: {path} conforms to okstra-schedule-gen Section Contract")
         return 0

package/src/commands/inspect/stage-map.mjs

@@ -7,7 +7,7 @@ Usage:
   okstra stage-map <task-key> --cwd <dir>      Resolve PROJECT_ROOT from <dir>
   okstra stage-map <task-key> --project <dir>  Use <dir> directly as PROJECT_ROOT
 
-Output: JSON { ok, taskKey, taskRoot, stages:[{stage_number,title,depends_on,step_count}], doneStages:[int] }.
+Output: JSON { ok, taskKey, taskRoot, state, sourcePlanPath, stages:[{stage_number,title,depends_on,step_count}], doneStages:[int] }.
 stages is [] when no implementation-planning Stage Map exists.
 `;