okstra 0.199.0 → 0.199.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.199.0",
+  "version": "0.199.1",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.199.0",
-  "builtAt": "2026-09-11T19:30:28.119Z",
+  "package": "0.199.1",
+  "builtAt": "2026-09-11T21:21:59.712Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/host-orchestration/implementation-planning.md

@@ -54,3 +54,10 @@ re-plan it without a RED step. Check `okstra stage-map <task-key>` first: when
 what is left. That command refuses unless the commit exists and the stage's
 conformance gate permits progress, so it cannot close a stage the run validator
 would have blocked.
+
+If `okstra stage-map` cannot read the prior plan during this planning run,
+follow the analysis packet's Stage Ledger recovery guidance. A notation error
+in an existing `dependsOn` cell is work for the new plan, not a reason to ask
+the user to edit JSON. Preserve the prior report, existing stage numbers and
+completed work; do not close or execute a stage from an unreadable map.
+An ambiguous dependency or stage identity remains a blocker.

package/runtime/prompts/profiles/implementation-planning.md

@@ -69,7 +69,7 @@ roles:
     - Every stage number in the ledger is taken. A new stage takes the next number after the highest one listed; numbers are never reused or reordered. **Not yet machine-enforced** — the validator for this rule lands with the plan-amendment feature.
     - The ledger answers two questions from two sources, and the block names both. `sourcePlan` is the plan the completed stages were actually built against; `latestPlan` is the plan the `stages` list came from and is therefore the numbering authority. When they differ, the completed work followed the former and the highest taken number comes from the latter.
     - A `planDivergence` entry means one of two things: the two plans disagree about a stage that is already `done` — the same number naming different work, or a completed stage the latest plan no longer declares — or the plan the completed stages were built against could not be read at all, so that comparison never ran. Both block the same way: do not pick one of the two plans yourself; register it as a `Blocks=approval` clarification row and assign no new stage number until it is resolved. Completed stages built against an *earlier* plan are not a divergence — that is the normal shape of an amended plan and the ledger folds it silently.
-    - The block is absent ONLY on a task's first planning run. Its absence then means there is no prior plan, not that no stage is done. When the ledger could not be read, the packet says so under the same heading with a reason instead of going silent — in that state, assign no new stage number and report the reason as a blocker.
+    - The block is absent ONLY on a task's first planning run. Its absence then means there is no prior plan, not that no stage is done. When the ledger could not be read, the packet names the source and reason. Continue planning to repair unambiguous dependency notation in the new report, retaining every stage number and title and every completed stage body. Record the original and corrected values with their source. Do not overwrite the prior report or select an older plan. Assign no new stage number until the corrected Stage Map validates; unresolved dependency meaning remains a blocker. The preparation behavior is covered by `tests/run/test_stage_ledger_prepare.py`; preservation of author intent remains a review guideline.
   - **Prior Planning Run (read before re-deriving anything):** on a re-run the packet carries a `## Prior Planning Run` block with the previous planning run's clarification rows, its Stage Map one line per stage, the findings its convergence left `contested` / `worker-unique`, and the path to the report itself. It is context, not an approved plan — the previous run did not reach approval. Use it so a stage you are not changing keeps the wording it already had and a settled question is not re-opened under a new `P-*` number; where the brief, the directive, or a clarification answer disagrees with it, they win. The block is absent on a first planning run and on a clarification re-run, which receives the same rows through `## Clarification Carry-In Extract` instead. **Enforced:** `okstra_ctl.prior_planning.build_prior_planning_summary` assembles it and `okstra_ctl.analysis_packet._prior_planning_block` renders it; nothing checks that a worker read it.
 - Primary focus areas:
   - requirement gaps

package/runtime/python/okstra_ctl/analysis_packet.py

@@ -538,10 +538,19 @@ def _stage_ledger_unavailable_block(notice: str) -> list[str]:
         "",
         f"- Reason: {notice.strip()}",
         "",
+        "Continue this planning run by reading that report and the implementation",
+        "carry records. Repair an unambiguous dependency notation error in the",
+        "new planning report, preserving every existing stage number and title",
+        "and the bodies of completed stages. Record each original and corrected",
+        "value with its source path. Do not overwrite the prior report or fall",
+        "back to an older plan. If the intended dependency cannot be established",
+        "from those records, report that uncertainty as a blocker; do not guess.",
+        "Validate the corrected Stage Map before treating its dependencies as facts.",
+        "",
         "Do not assign a number to any new stage in this state. A number taken",
         "by a plan this run could not read would collide with the completed",
         "work under it, and that collision stays silent until integration.",
-        "Report this as a blocker instead.",
+        "Until the corrected map validates, keep new stage numbering blocked.",
         "",
     ]
 

package/runtime/python/okstra_ctl/stage_map.py

@@ -159,15 +159,17 @@ def _stage_map_table_lines(text: str, source_plan_path: str) -> list[str]:
     ]
 
 
-def _parse_depends_on(
+def parse_stage_dependencies(
     value: str, row_number: int, source_plan_path: str,
 ) -> tuple[int, ...]:
+    """계획 작성 검증과 실행 시 읽기가 같은 의존성 문법을 사용한다."""
+    value = value.strip()
     if value in {"", "(none)"}:
         return ()
     dependencies: list[int] = []
     for token in value.split(","):
         normalized = token.strip()
-        if not normalized.isdigit() or int(normalized) < 1:
+        if not re.fullmatch(r"[1-9][0-9]*", normalized):
             raise StageMapError(
                 "stage_map",
                 f"Stage Map row {row_number} has invalid depends-on token "
@@ -215,7 +217,7 @@ def _parse_stage_map_row(
     return StageMapStage(
         stage_number,
         cells[1],
-        _parse_depends_on(cells[2].strip(), row_number, source_plan_path),
+        parse_stage_dependencies(cells[2], row_number, source_plan_path),
         step_count,
         cells[4],
     )
@@ -337,7 +339,7 @@ def _parse_data_stage_map_row(
     return StageMapStage(
         stage_number,
         title,
-        _parse_depends_on(depends_on.strip(), row_number, source_plan_path),
+        parse_stage_dependencies(depends_on, row_number, source_plan_path),
         step_count,
         exit_summary,
     )

package/runtime/schemas/final-report-v2.0.schema.json

@@ -7741,6 +7741,7 @@
         "dependsOn": {
           "type": "string",
           "minLength": 1,
+          "pattern": "^\\s*(?:\\(none\\)|[1-9][0-9]*(?:\\s*,\\s*[1-9][0-9]*)*)\\s*$",
           "description": "Literal Stage Map depends-on cell: `(none)` or a comma-separated stage number list."
         },
         "stepCount": {

package/runtime/schemas/final-report-v3.0.schema.json

@@ -7839,6 +7839,7 @@
         "dependsOn": {
           "type": "string",
           "minLength": 1,
+          "pattern": "^\\s*(?:\\(none\\)|[1-9][0-9]*(?:\\s*,\\s*[1-9][0-9]*)*)\\s*$",
           "description": "Literal Stage Map depends-on cell: `(none)` or a comma-separated stage number list."
         },
         "stepCount": {

package/runtime/skills/okstra-run/SKILL.md

@@ -354,6 +354,13 @@ re-plan it without a RED step. Check `okstra stage-map <task-key>` first: when
 what is left. That command refuses unless the commit exists and the stage's
 conformance gate permits progress, so it cannot close a stage the run validator
 would have blocked.
+
+If `okstra stage-map` cannot read the prior plan during this planning run,
+follow the analysis packet's Stage Ledger recovery guidance. A notation error
+in an existing `dependsOn` cell is work for the new plan, not a reason to ask
+the user to edit JSON. Preserve the prior report, existing stage numbers and
+completed work; do not close or execute a stage from an unreadable map.
+An ambiguous dependency or stage identity remains a blocker.
 <!-- END FRAGMENT: host-orchestration-implementation-planning -->
 
 <!-- BEGIN FRAGMENT: host-orchestration-implementation -->

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

@@ -30,6 +30,7 @@ from okstra_ctl.stage_map import (  # noqa: E402
     STAGE_MAP_HEADING,
     StageMapError,
     StageMapStage,
+    parse_stage_dependencies,
     parse_stage_map_text,
     schema_v2_report,
 )
@@ -79,17 +80,6 @@ def _check_stage_map_present(text: str) -> List[ValidationError]:
     return []
 
 
-def _parse_depends_on_cell(raw: str) -> List[int] | None:
-    """Stage numbers from schema-v2 `stageMap[].dependsOn`."""
-    value = raw.strip()
-    if value in ("(none)", ""):
-        return []
-    try:
-        return [int(x.strip()) for x in value.split(",") if x.strip()]
-    except ValueError:
-        return None
-
-
 def _stage_numbers_monotonic(
     stages: List[StageMapStage],
 ) -> List[ValidationError]:
@@ -495,11 +485,16 @@ def _data_stage_metas(
     stage_map: List[dict],
 ) -> Tuple[List[StageMapStage], List[ValidationError]]:
     rows = []
-    for row in stage_map:
+    errors = []
+    for row_number, row in enumerate(stage_map, start=1):
         if not isinstance(row, dict) or not isinstance(row.get("stage"), int):
             continue
-        depends = _parse_depends_on_cell(str(row.get("dependsOn") or ""))
-        if depends is None:
+        try:
+            depends = parse_stage_dependencies(
+                str(row.get("dependsOn") or ""), row_number, ""
+            )
+        except StageMapError as exc:
+            errors.append(ValidationError("S2", row["stage"], exc.reason))
             continue
         rows.append(StageMapStage(
             row["stage"],
@@ -508,7 +503,7 @@ def _data_stage_metas(
             row.get("stepCount") if isinstance(row.get("stepCount"), int) else -1,
             str(row.get("exitContractSummary") or ""),
         ))
-    return rows, _stage_numbers_monotonic(rows)
+    return rows, errors or _stage_numbers_monotonic(rows)
 
 
 def _check_data_slice_tdd(