okstra 0.157.0 → 0.158.0

package/docs/for-ai/skills/okstra-inspect.md

@@ -236,7 +236,7 @@ Enter code mode only when the user explicitly requests it, such as "including th
 
 ## Output rules
 
-- Answer concisely in Korean.
+- Answer in Korean, spelling out task ids, phase names, and status values on first mention.
 - Prefer project-relative paths.
 - Show disk field values as-is without normalizing.
 - Clearly indicate an awaiting-approval state.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.157.0",
+  "version": "0.158.0",
   "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.157.0",
-  "builtAt": "2026-08-07T06:39:25.315Z",
+  "package": "0.158.0",
+  "builtAt": "2026-08-07T09:36:00.766Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/python/okstra_ctl/model_discovery.py

@@ -53,7 +53,12 @@ def _dispatch_effort(execution: str, role: str) -> str:
 
 @lru_cache(maxsize=1)
 def agy_models(agy_bin: str = "agy") -> tuple[str, ...]:
-    """Live `agy models` list, or () when agy is unavailable (non-blocking)."""
+    """Live `agy models` ids, or () when agy is unavailable (non-blocking).
+
+    agy prints one model per line as `<id>\\t<display label>`; only the id is
+    comparable to a catalog execution value, so the label column is dropped.
+    A line with no tab is already bare and passes through unchanged.
+    """
     try:
         proc = subprocess.run(
             [agy_bin, "models"],
@@ -63,7 +68,8 @@ def agy_models(agy_bin: str = "agy") -> tuple[str, ...]:
         return ()
     if proc.returncode != 0:
         return ()
-    return tuple(line.strip() for line in proc.stdout.splitlines() if line.strip())
+    ids = (line.split("\t", 1)[0].strip() for line in proc.stdout.splitlines())
+    return tuple(model_id for model_id in ids if model_id)
 
 
 def _codex_config_path() -> Path:

package/runtime/python/okstra_ctl/schedule_semantics.py

@@ -29,10 +29,11 @@ _STAGE_FIELDS = {"stageNumber", "title", "dependsOn", "stepCount"}
 _TASK_HEADING_RE = re.compile(r"^###\s+(\d+)\.\s+(\S.*?)\s*$", re.MULTILINE)
 _WORK_BREAKDOWN_HEADER = ["Stage", "Title", "Steps", "Depends On", "Days"]
 _WORK_BREAKDOWN_SEPARATOR = ["---:", "---", "---:", "---", "---:"]
-# No `taskType`: it printed okstra's own phase name at a reader who has no
-# phases, and the per-task Status field already states the same thing in words.
+# No `Task ID` and no `taskType`: the schedule is shared with people who do not
+# run okstra, so a task is named by its work and a row binds to the selection by
+# its `#` position — the same rule the `### <n>.` blocks follow.
 _AT_A_GLANCE_HEADER = [
-    "#", "Task ID", "Title", "Category", "Priority", "Effort", "Days", "Risk",
+    "#", "작업", "Category", "Priority", "Effort", "Days", "Risk",
 ]
 _EFFORT_HEADER = ["Size", "Criteria", "Day(s)"]
 _EFFORT_SIZES = {"S", "M", "L", "XL", "XXL"}
@@ -596,17 +597,16 @@ def _parse_at_a_glance_table(
             task_id = cells[1] if len(cells) > 1 else "<unknown>"
             violations.append(
                 f"At a Glance: noncanonical row for task {task_id} "
-                "requires 8 columns"
+                "requires 7 columns"
             )
             continue
-        effort_tokens = cells[5].split()
+        effort_tokens = cells[4].split()
+        position = cells[0].strip()
         rows.append(_AtAGlanceRow(
-            task_id=cells[1],
+            task_id=f"#{position}",
             effort=effort_tokens[0].strip("*") if effort_tokens else "",
-            days_text=cells[6],
-            days=_parse_day_range(
-                cells[6], f"At a Glance {cells[1]}"
-            ),
+            days_text=cells[5],
+            days=_parse_day_range(cells[5], f"At a Glance row {position}"),
         ))
     return rows, violations
 
@@ -621,7 +621,7 @@ def _parse_at_a_glance_rows(
         if split_pipe_row(line) == _AT_A_GLANCE_HEADER
     ]
     if not header_indexes:
-        return [], ["At a Glance: missing canonical 8-column table"]
+        return [], ["At a Glance: missing canonical 7-column table"]
     rows: list[_AtAGlanceRow] = []
     violations: list[str] = []
     for header_index in header_indexes:
@@ -636,27 +636,37 @@ def _parse_at_a_glance_rows(
 def _validated_at_a_glance_rows(
     text: str, tasks: tuple[SelectionTask, ...],
 ) -> tuple[dict[str, _AtAGlanceRow], list[str]]:
+    """Rows keyed by task-id, resolved from each row's `#` position.
+
+    The table names tasks by their work, so position is what ties a row to the
+    selection — the n-th row is the n-th task, the same rule the `### <n>.`
+    blocks follow.
+    """
     rows, violations = _parse_at_a_glance_rows(text)
-    indexed: dict[str, list[_AtAGlanceRow]] = {}
+    seen: dict[str, list[_AtAGlanceRow]] = {}
     for row in rows:
-        indexed.setdefault(row.task_id, []).append(row)
-    known_task_ids = {task.task_id for task in tasks}
-    for task_id, matches in indexed.items():
-        if len(matches) > 1:
-            violations.append(f"At a Glance: duplicate Task ID {task_id}")
-        if task_id not in known_task_ids:
-            violations.append(f"At a Glance: unknown Task ID {task_id}")
-    for task in tasks:
-        if len(indexed.get(task.task_id, [])) != 1:
+        seen.setdefault(row.task_id, []).append(row)
+    validated: dict[str, _AtAGlanceRow] = {}
+    for position, task in enumerate(tasks, start=1):
+        matches = seen.pop(f"#{position}", [])
+        if len(matches) != 1:
             violations.append(
-                f"At a Glance: task {task.task_id} "
-                "requires exactly one canonical row"
+                f"At a Glance: task {task.task_id} requires exactly one row "
+                f"at position {position}"
             )
-    validated = {
-        task_id: matches[0]
-        for task_id, matches in indexed.items()
-        if task_id in known_task_ids and len(matches) == 1
-    }
+            continue
+        row = matches[0]
+        validated[task.task_id] = _AtAGlanceRow(
+            task_id=task.task_id,
+            effort=row.effort,
+            days_text=row.days_text,
+            days=row.days,
+        )
+    for leftover, matches in seen.items():
+        violations.append(
+            f"At a Glance: row {leftover} has no matching task "
+            f"({len(tasks)} tasks selected)"
+        )
     return validated, violations
 
 
@@ -883,11 +893,12 @@ def _validate_task_section_coverage(
 
 
 def _extract_breakdown_rows(
-    text: str,
+    text: str, tasks: tuple[SelectionTask, ...],
 ) -> tuple[list[_BreakdownRow], list[str], list[tuple[str, str]]]:
-    glance_rows, _ = _parse_at_a_glance_rows(text)
+    # The n-th `### <n>.` block is the n-th selected task; neither the heading
+    # nor the At a Glance row prints an id to match on.
     blocks, violations = _task_section_blocks(
-        text, [row.task_id for row in glance_rows]
+        text, [task.task_id for task in tasks]
     )
     if violations:
         return [], violations, blocks
@@ -1002,7 +1013,7 @@ def _validate_topological_order(
 def _validate_work_breakdowns(
     text: str, tasks: tuple[SelectionTask, ...],
 ) -> tuple[list[_BreakdownRow], list[str]]:
-    rows, violations, blocks = _extract_breakdown_rows(text)
+    rows, violations, blocks = _extract_breakdown_rows(text, tasks)
     violations.extend(_validate_task_section_coverage(blocks, tasks))
     indexed: dict[tuple[str, int], list[tuple[int, _BreakdownRow]]] = {}
     for position, row in enumerate(rows):

package/runtime/python/okstra_ctl/stage_map.py

@@ -62,7 +62,12 @@ _PLANNING_TASK_NARRATIVE_FIELDS = (
     "crossProjectDependencies",
     "dependencyMigrationRisk",
     "recommendedOption",
+    "requirementCoverage",
 )
+# The report's own plain-language summary. `decisions`, `actions` and `blockers`
+# are deliberately not carried: they ask the reader to approve something, and a
+# schedule states work rather than requesting sign-off.
+_REPORT_SUMMARY_FIELDS = ("headline", "outcome", "whyItMatters")
 
 
 @dataclass(frozen=True)
@@ -362,8 +367,8 @@ def parse_stage_map_file(markdown_path: Path) -> list[StageMapStage]:
     return _parse_schema_v2_stage_map(data, str(data_path))
 
 
-def _planning_section(markdown_path: Path) -> dict[str, Any]:
-    """The schema-v2 sidecar's `implementationPlanning` block, `{}` for v1."""
+def _schema_v2_report(markdown_path: Path) -> dict[str, Any]:
+    """The schema-v2 sidecar as a whole, `{}` for a v1 report."""
     data_path = Path(markdown_path).resolve().with_suffix(".data.json")
     if not data_path.exists():
         return {}
@@ -373,7 +378,12 @@ def _planning_section(markdown_path: Path) -> dict[str, Any]:
         raise StageMapError("stage_map", str(exc), str(data_path)) from exc
     if not isinstance(data, dict) or data.get("schemaVersion") != "2.0":
         return {}
-    planning = data.get("implementationPlanning")
+    return data
+
+
+def _planning_section(markdown_path: Path) -> dict[str, Any]:
+    """The report's `implementationPlanning` block, `{}` for v1."""
+    planning = _schema_v2_report(markdown_path).get("implementationPlanning")
     return planning if isinstance(planning, dict) else {}
 
 
@@ -397,17 +407,25 @@ def _stage_narratives(value: Any) -> dict[int, dict[str, Any]]:
 
 def load_planning_detail(markdown_path: Path) -> PlanningDetail:
     """Read one report's narrative rows; empty for a schema-v1 report."""
-    planning = _planning_section(markdown_path)
-    if not planning:
+    report = _schema_v2_report(markdown_path)
+    planning = report.get("implementationPlanning")
+    if not isinstance(planning, dict) or not planning:
         return PlanningDetail({}, {})
-    return PlanningDetail(
-        _stage_narratives(planning.get("stages")),
-        {
-            field: planning[field]
-            for field in _PLANNING_TASK_NARRATIVE_FIELDS
-            if field in planning
-        },
-    )
+    task = {
+        field: planning[field]
+        for field in _PLANNING_TASK_NARRATIVE_FIELDS
+        if field in planning
+    }
+    summary = report.get("humanSummary")
+    if isinstance(summary, dict):
+        carried = {
+            field: summary[field]
+            for field in _REPORT_SUMMARY_FIELDS
+            if field in summary
+        }
+        if carried:
+            task["reportSummary"] = carried
+    return PlanningDetail(_stage_narratives(planning.get("stages")), task)
 
 
 def merge_planning_detail(

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

@@ -79,7 +79,8 @@ When a facet needs a task but the user did not name one:
 
 ## Output Rules (shared)
 
-- Responses should be concise and written in Korean unless the user requests otherwise.
+- Write responses in Korean unless the user requests otherwise. Spell out task ids, phase names, and
+  status values the first time each appears — the reader has not seen the report you are summarizing.
 - Use project-relative paths whenever possible.
 - If there is no recent report, display `--`.
 - If a specific task does not exist, explicitly state that it cannot be found based on `task-catalog.json`.

package/runtime/skills/okstra-schedule-gen/SKILL.md

@@ -15,7 +15,7 @@ Generate a consolidated work schedule for the selected `implementation-planning`
 
 **Do NOT use** for single-task analysis (use `okstra-inspect status`) or to execute one task (use `okstra-run`).
 
-Public invocation: `/okstra-schedule-gen [task-group]`. A title or directive may be supplied in the host conversation. If no title is supplied, derive a default from `task-group` (e.g. `uploadFont` → `uploadFont — Work Schedule`).
+Public invocation: `/okstra-schedule-gen [task-group]`. A title or directive may be supplied in the host conversation. If none is, name the schedule after the work itself — read the task titles in scope and write what they do (e.g. `폰트 업로드 경로 개선 — 작업 일정`). Never title it after the group token: that is a directory name, not what the work is.
 
 ## Step 0: Preflight
 
@@ -33,17 +33,34 @@ Parse the stdout JSON. `ok: true` → carry `projectRoot` as a literal string an
 If the call fails with `unknown command: preflight`, the `okstra` binary on PATH predates this skill — tell the user to update it (`npm i -g okstra@latest`), then stop (`/okstra-setup` does not update the binary).
 <!-- END FRAGMENT: preflight-outdated-cli -->
 
+## What the finished document looks like
+
+The rules below are long because each one was learned from a published schedule
+that failed a reader. This is the shape they add up to — read it once before
+Step 4, and again at Step 7.
+
+| Section | Holds | Never holds |
+|---|---|---|
+| `## At a Glance` | one row per task: work name, category, priority, effort, days, risk | task-ids, taskType, a `Task ID` column |
+| `## Executive Summary` | `**목적**`, `**달라지는 것**` (limits included), scope/order, how the days were derived; then the effort and priority/risk scales | okstra vocabulary, the plan's review history |
+| `## Task Dependency Graph` | cross-task edges — **omitted entirely** when there are none | stage order (the Work Breakdown owns it) |
+| `## Gantt Chart` | one bar per selected stage, label and bar only | `days=`, per-row `! crit`/`est` |
+| `## Task Details` | per task: Item/Detail, Problem, Solution, Work Breakdown, one block per stage (`Steps` + `Exit criteria`), Verification Commands, Rollback | `Value`, `Acceptance`, a risk section, a cross-task section, a next-actions list |
+
+Every one of those "never holds" entries was in a shipped schedule. Four
+restated a table that sat directly above or below them.
+
 ## Audience & authority (READ FIRST — drives everything below)
 
+**The schedule is shared with people who do not run okstra.** It is the team's work-plan document, not a record of a run. The body names neither the tool nor its vocabulary — `okstra`, `task-group`, `task-key`, `taskType`, a run's phase names — and the validator refuses a body that does. The title is the work's name, the one metadata line is `> 작성일 <YYYY-MM-DD> · 대상 저장소 <repo>`, and At a Glance identifies each task by name rather than by task-id. That extends to paths: a plan often puts its own scaffolding under the run's working tree — `.okstra/…`, or the `qa/…` scratch it holds — and those are places the reader cannot open and does not own. Name the artefact instead ("계약 캡처 도구", "위반 대장") and keep the path out. Real repository paths — `package.json`, `src/**`, `eval/**`, `.github/workflows/**` — are content and stay.
+
 **The schedule is a client-facing work plan.** It assumes the team has all permissions and can proceed without further approval. Even when the underlying per-task reports flag blocking items, missing approvals, or "items requiring user confirmation", **the schedule MUST NOT surface them** — those belong in the internal report. Never emit a decision checklist, a `#### Items requiring user confirmation` sub-section, `Done`/`Ready?`/`Blocking Decisions` columns, or checkbox lists; "Status" reflects work phase only.
 
 **Assume the user and their team hold full authority and every permission required.** External approvals, access grants, sign-off, and vendor coordination are treated as already satisfied unless a report names a concrete external dependency outside the user's control. Concretely:
 
 - **Effort sizing & day totals** count engineering work only — strip approval-waiting / coordination buffers from source sizings (note the adjustment in `## Executive Summary` if material).
 - **Gantt bars** represent engineering duration only; no dead-time gaps for approval cycles. `(after <TASK-ID>)` marks genuine engineering dependencies only.
-- **Risk Mitigation Strategy** lists real engineering risks (data loss, regression surface, rollback path) — permission/coordination items are dropped.
-- **Recommended Immediate Actions / Next Action** are concrete engineering steps; items like "permission check", "approval request", "stakeholder alignment" MUST NOT be emitted.
-- **Cross-Task Dependencies** covers engineering coupling only (shared modules, release order, package versions).
+- **Steps and Exit criteria** are concrete engineering work; items like "permission check", "approval request", "stakeholder alignment" MUST NOT be emitted.
 
 **The schedule must be self-contained.** Opaque codes pulled from internal reports (`FC-5`, `UC-12`, `M1`, decision-item letters, …) must not appear unresolved. Choose one per identifier: **Form A** (≤3 codes) — replace the code inline with a 5–20 character one-line description of the item; **Form B** (≥4 recurring codes) — keep the codes and emit a `## Glossary` table as the last section resolving every one. Decision-item letters (`A1`, `B2`, …) are approval items and may not appear at all. TASK-IDs listed in `## At a Glance` need neither.
 
@@ -117,7 +134,7 @@ Record the chosen `selectedStages` for this task. Reject and re-prompt any custo
 
 The canonical categories come from `scripts/okstra_ctl/work_categories.py::WORK_CATEGORIES`. Do not infer or publish another category.
 
-**There are no phase buckets and no priority table.** `## Task Details` holds one `### <n>. <Title>` block per in-scope task, numbered from 1 in At a Glance order. The heading is the work's name — the task-id is a machine key and belongs in the At a Glance row, not in a heading the reader has to decode; the block binds to its row by number. At a Glance is already sorted Priority-first, so that ordering carries priority; sequence lives in the stages; and `## Recommended Immediate Actions` is the one place that says what to do next. In the per-task `Item / Detail` table, `Status` says where the work stands in plain words — "구현 계획 승인됨 — 실행 미착수", not `implementation-planning / implementation-planning`. Derive it from `taskType` and `workflow.currentPhase`, but never print those tokens: they are okstra's phase names and the reader has no phases.
+**There are no phase buckets and no priority table.** `## Task Details` holds one `### <n>. <Title>` block per in-scope task, numbered from 1 in At a Glance order. The heading is the work's name — the task-id is a machine key and belongs in the At a Glance row, not in a heading the reader has to decode; the block binds to its row by number. At a Glance is already sorted Priority-first, so that ordering carries priority; sequence lives in the stages; and what to do next is Stage 1's first step. In the per-task `Item / Detail` table, `Status` says where the work stands in plain words — "구현 계획 승인됨 — 실행 미착수", not `implementation-planning / implementation-planning`. Derive it from `taskType` and `workflow.currentPhase`, but never print those tokens: they are okstra's phase names and the reader has no phases.
 
 Order At a Glance by Priority (`P0` first), breaking ties by `workCategory` in this canonical order: `bugfix`, `feature`, `refactor`, `ops`, `improvement`. A task whose `workCategory` is unmatched or missing sorts last within its priority and keeps its raw value in the `Category` cell — never substitute a category that is not in that list.
 
@@ -134,10 +151,16 @@ Selecting which source rows belong in a schedule is not summarising. Dropping a
 
 **Stage titles and every table cell are written in the schedule's prose language.** Headings and field labels stay English literals; the content beside them does not. A Work Breakdown whose `Title` column is English next to a `Steps` table in Korean makes the reader switch languages inside one block. The selection contract carries the same titles the schedule prints, so the two stay comparable.
 
-**A stage block is `Steps` plus `Exit criteria`, and nothing else.** The `Steps` table comes from `stepwiseExecution` — one row per step with what it does (keep the leading `RED:` / `GREEN:` marker), the files it touches, and what the executor should see when it succeeds, from that step's `expected`. `Exit criteria` is one line from `exitContract` saying when the stage is finished.
+**`## Executive Summary` opens with `**목적**` and `**달라지는 것**`; the validator requires both.** A reader who opens only that section must learn why the work happens and what is true when it ends — scope and day arithmetic alone say neither. The material is in the report's `humanSummary` (`headline`, `outcome`, `whyItMatters`), which `okstra stage-map` carries as `planning.reportSummary`. Rewrite it: that field addresses an approver ("your two questions", "the option you approved"), and that framing must not survive. `decisions`, `actions` and `blockers` are not carried at all — they ask for sign-off.
+
+**State the limits in the outcome list.** When the work stops short of what its name suggests, the summary says so. Here the migration ships with three ports still vendor-shaped, so the schedule says "디렉터리 구조 완료, 격리 미완" rather than letting the reader assume the isolation is finished. A summary that only lists wins is the kind a reader stops trusting on the first surprise.
+
+**A stage block is `Steps` plus `Exit criteria`, and nothing else.** The `Steps` table comes from `stepwiseExecution` — one row per step with what it does (keep the leading `RED:` / `GREEN:` marker), the files it touches, and what the executor should see when it succeeds, from that step's `expected`. In the 대상 column separate entries with `<br>`, not a comma: a comma-joined path list stretches that column and squeezes the two text columns into a gutter. `Exit criteria` is one line from `exitContract` saying when the stage is finished.
 
 Do not render `sliceValue` — it argues why the plan sliced the work this way, which is a reviewer's question, not an implementer's. Do not render `acceptance` alongside `exitContract`: they restate each other. Measured on one real plan, `acceptance`'s four claims all reappeared in `exitContract`, which then added two more. Sort `Verification Commands` `pre` → `mid` → `post` and introduce those three values above the table — source order interleaves them, and a reader working down the table would run a precondition after the checks it gates.
 
+**The schedule has no risk section, no cross-task section and no next-actions list.** Every row those carried restated a stage: a risk's mitigation *is* the stage that answers it, an upstream dependency *is* the step that gates on it, and the next action *is* Stage 1's first step. Carry `dependencyMigrationRisk` and `crossProjectDependencies` by making sure the stage they point at says what they demand — and put anything genuinely not a stage (a freeze agreed with another team, a coupling the stages only imply) in that task's **Solution** or **Repo** cell.
+
 **Transcribing means the content, never the source row's `id`.** `VC-001`, `RB-003`, `XP-001`, `DM-002`, `EO-015` and their kin index a report the schedule's reader cannot open, so the self-contained rule rejects them and the validator enforces it. Drop the id column, and where a row's body cites a sibling code, replace the citation with the thing it names ("the boot probe asserts all 29 keys", not "VC-006").
 
 ### Step 5: Gantt decision (render by default)
@@ -227,6 +250,15 @@ Reached only after both Step 5.5 gates return `pass`. Promote the verified same
 2. Run `python3 ~/.okstra/lib/validators/validate-schedule.py <output-path>` as a final format check; use the repository validator only when the installed validator is absent.
 3. Delete the temporary `.selection.json` only after that final check passes. Do not print the Step 8 message while the selection contract still exists or validation is failing.
 
+**Then read the document once as its reader.** The validator settles structure, arithmetic, controlled vocabulary and run-internal leakage; it cannot judge any of the following, and each has shipped in a published schedule before:
+
+- Does the summary say **why** the work happens and what is **true when it ends** — including what stays unfinished? A list of wins that omits a known limit is the kind a reader stops trusting at the first surprise.
+- Does every step say what to **do**, or does some row only explain why the plan chose this shape? The second is the report's voice, not the schedule's.
+- Does any sentence assume the reader watched the plan being argued — a cited objection, a prior revision, "the reporter's rationale"?
+- Is anything said twice? A section that restates a table, a cell that repeats its neighbour, a sentence that ends "…is in the table below" — the redirect is the tell.
+- Would a reader who is not on this team understand every code and label on the page?
+- If a translation exists, do its section count, stage blocks, steps per stage, verification rows, rollback rows and day figures match the original exactly? Compare the counts; a translation that drops rows looks complete on its own.
+
 ### Step 8: Completion message (Korean)
 
 ```
@@ -253,7 +285,10 @@ Reached only after both Step 5.5 gates return `pass`. Promote the verified same
 
 ## Output Rules
 
-- All user-facing messages in Korean; schedule body prose Korean, identifiers/headings/field labels English (template literals).
+- All user-facing messages in Korean; schedule body prose Korean by default, headings/field labels English (template literals).
+- **The document declares its language** as `lang:` in frontmatter, and the validator checks it against that language's labels — a faithful translation must not fail for being a translation. `SCHEDULE_LABELS` in `validators/validate-schedule.py` is the SSOT for which languages exist and what their title suffix, metadata line, summary labels and scale headers are. Writing a schedule in a language absent from that table means adding it there first.
+- **A translated schedule is a sibling file, not a rewrite**: `<name>-<lang>.md` beside the original. It carries the same structure — same section count, same stage blocks, same step count per stage, same verification and rollback row counts, same day figures. Compare those counts against the original before publishing; a translation that quietly drops rows is the failure mode here, and it does not show up in either gate.
+- The document names no okstra concept. Title, metadata line and At a Glance carry the work's name and its repository — not the task-key, the task-group, or the run's phase.
 - Use project-relative paths in completion messages.
 - Each detail `Status` is derived from `taskType` and `workflow.currentPhase` but written in plain words; `workStatus` only filters candidates and is never printed.
 - Per-task section Work Breakdown rows are **selected stages**, not free-form items; done stages are summarized, never scheduled forward.

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

@@ -1,20 +1,31 @@
 ---
-title: OKSTRA Schedule - {{TASK_KEY}}
-id: {{FM_ID}}
-tags: {{FM_TAGS}}
-status: new
-aliases: {{FM_ALIASES}}
+title: {{TITLE}} — 작업 일정
 date: {{TASK_DATE}}
-task-id: "{{TASK_ID}}"
-task-group: "{{TASK_GROUP}}"
-project-id: "{{PROJECT_ID}}"
-taskType: "{{FM_TASK_TYPE}}"
+lang: "ko"
+tags: ["schedule"]
+status: new
 ---
 
-# <Title> — Work Schedule
+<!-- `lang` decides which labels the validator checks. Section headings and
+     field labels (`## At a Glance`, `**Problem**:`, `| Stage | Title | …`) stay
+     English literals in every language; the words around them follow `lang`.
+     Known languages and their labels live in `SCHEDULE_LABELS` in
+     `validators/validate-schedule.py` — add a language there before writing one.
+
+     ko: title `— 작업 일정`, meta `> 작성일 … · 대상 저장소 …`,
+         summary `**목적**` / `**달라지는 것**`, scale `| Priority | 기준 |`
+     fr: title `— Planning de travail`, meta `> Rédigé le … · Dépôt concerné …`,
+         summary `**Objectif**` / `**Ce qui aura changé à la fin**`,
+         scale `| Priority | Critère |` -->
+
+<!-- The schedule is shared with people who do not run okstra. Neither the tool
+     nor its vocabulary — task-group, task-key, taskType, the run's phase names —
+     appears anywhere in the body, and the validator refuses a body that carries
+     them. Frontmatter stays tooling-only and is not rendered. -->
 
-> Generated: <YYYY-MM-DD HH:MM> | Project: <project-id> | Task Group: <task-group>
-> Source: okstra <mode> (<N> tasks included, <M> done excluded)
+# <작업 이름> — 작업 일정
+
+> 작성일 <YYYY-MM-DD> · 대상 저장소 <repo>
 
 ---
 
@@ -28,9 +39,9 @@ taskType: "{{FM_TASK_TYPE}}"
      implementation-planning does not estimate duration. `[NEEDS-PLANNING]` is
      reserved for a task with NO planning report at all. -->
 
-| # | Task ID | Title | Category | Priority | Effort | Days | Risk |
-|---|---------|-------|----------|----------|--------|------|------|
-| 1 | <TASK-ID> | <Title> | <category> | <P0~P3> | <S/M/L/XL/XXL> | <X.X> ~ <Y.Y> (est) | <risk> |
+| # | 작업 | Category | Priority | Effort | Days | Risk |
+|---|------|----------|----------|--------|------|------|
+| 1 | <작업 이름> | <category> | <P0~P3> | <S/M/L/XL/XXL> | <X.X> ~ <Y.Y> (est) | <risk> |
 
 **Effort distribution**: S × <n> / M × <n> / L × <n> / XL × <n> / XXL × <n>
 **Risk distribution**: Very Low × <n> / Low × <n> / Medium × <n> / Med-High × <n> / High × <n>
@@ -40,13 +51,30 @@ taskType: "{{FM_TASK_TYPE}}"
 
 ## Executive Summary
 
-<2-4 sentences — what this schedule covers and the execution strategy.>
+<!-- A reader who opens only this section must learn why the work is being done
+     and what is true when it ends. Both labels are required and the validator
+     checks for them.
+
+     `목적` — the problem in today's system, in its own terms. Not "migrate to
+     NestJS" (that is the what); rather what is wrong or missing now and what
+     this changes about it. Source: the report's `humanSummary.headline` /
+     `whyItMatters`, rewritten for someone who never saw the report — it is
+     written at an approver ("your two questions", "the option you approved")
+     and that framing must not survive into the schedule.
+
+     `달라지는 것` — a bullet list of the end state, each item something a
+     reader could later check. State the limits too: if the work stops short of
+     what its name suggests, say so here rather than letting the reader assume
+     otherwise. -->
 
-<!-- One bullet per in-scope task, naming the stages actually selected. This is
-     the stage roster, not a priority bucket — At a Glance is sorted
-     Priority-first and that ordering is where priority lives. -->
+**목적** — <오늘 무엇이 문제이고 이 작업이 그것을 어떻게 바꾸는지>
 
-- **<TASK-ID>**: stages <n>–<m> selected (<total> steps) — <summary>
+**달라지는 것**
+
+- <완료 시점에 참이 되는 것, 확인 가능한 형태로>
+- <미완으로 남는 것이 있으면 그것도>
+
+**범위와 순서** — <몇 개 stage / step, 의존 형태, 병행 가능한 준비 작업>
 
 ### Effort Sizing Criteria
 
@@ -195,8 +223,22 @@ Stage 3           ██████░░░░
      executor should see when it succeeds — the step's own `expected`, written
      as an outcome they can check, not pasted.
 
+     The 대상 column separates entries with `<br>`, never a comma — a
+     comma-joined list stretches the column and pushes the two text columns
+     into a narrow gutter. It lists repository paths only. A plan that scaffolds under
+     the run's working tree (`.okstra/…`, `qa/…`) names the artefact there
+     instead — "계약 캡처 도구", "위반 대장" — because the reader neither owns
+     nor can open that tree. The validator refuses such a path.
+
      `Exit criteria` is one line from `exitContract`: when the stage is done.
 
+     There is no risk section, no cross-task section and no "what to do next"
+     list. Every row those carried restated a stage — a risk's mitigation is
+     the stage that answers it, an upstream dependency is the step that gates
+     on it, and the next action is Stage 1's first step. Anything that is
+     genuinely not a stage (a freeze agreed with another team, a coupling the
+     stages only imply) belongs in that task's **Solution** or **Scope**.
+
      Do NOT render `sliceValue`. It argues why the plan sliced the work this
      way, which is a reviewer's question; an implementer gets nothing from it.
      Do NOT render `acceptance` next to `exitContract` — they restate each
@@ -208,8 +250,8 @@ Stage 3           ██████░░░░
 
 | Step | 작업 | 대상 | 기대 결과 |
 |---:|---|---|---|
-| 1 | RED: <무엇을 왜 하는지> | `<files>` | <성공했을 때 보이는 것> |
-| 2 | GREEN: <무엇을 왜 하는지> | `<files>` | <성공했을 때 보이는 것> |
+| 1 | RED: <무엇을 왜 하는지> | `<file>`<br>`<file>` | <성공했을 때 보이는 것> |
+| 2 | GREEN: <무엇을 왜 하는지> | `<file>` | <성공했을 때 보이는 것> |
 
 **Exit criteria**: <이 stage 가 끝났다고 판정하는 상태>
 
@@ -240,41 +282,6 @@ Stage 3           ██████░░░░
 
 ---
 
-## Cross-Task Dependencies & Shared Concerns
-
-<!-- When the planning report carries `crossProjectDependencies`, render one row
-     per entry before any prose. Prose covers only what those rows do not. -->
-
-| Direction | Project | Required Work | Verification Signal |
-|-----------|---------|---------------|---------------------|
-| upstream-precondition | <project> | <requiredWork> | <verificationSignal> |
-
-<free-form prose — inter-task overlap, shared packages, release order>
-
----
-
-## Risk Mitigation Strategy
-
-<!-- When the planning report carries `dependencyMigrationRisk`, render one row
-     per entry. Additional numbered prose items may follow for risks the report
-     does not carry. -->
-
-| Kind | Item | Impact | Mitigation |
-|------|------|--------|------------|
-| order | <item> | <impact> | <mitigation> |
-
----
-
-## Recommended Immediate Actions
-
-<!-- The single place the schedule says what to do next. With several tasks in
-     scope, lead each task's first action with its `<TASK-ID>` and keep them in
-     At a Glance order — that ordering is already Priority-first, so a separate
-     priority table would restate the At a Glance row and this list at once. -->
-
-- <action>
-- <action>
-
 <!-- OPTIONAL: ## Glossary
      Include ONLY when the body uses opaque codes (FC-N, UC-N, M-N, ...).
      Header literal `| Code | Description |` is required. Every code in body

package/runtime/validators/validate-schedule.py

@@ -37,9 +37,6 @@ REQUIRED_SECTIONS_IN_ORDER: list[str] = [
     "## At a Glance",
     "## Executive Summary",
     "## Task Details",
-    "## Cross-Task Dependencies & Shared Concerns",
-    "## Risk Mitigation Strategy",
-    "## Recommended Immediate Actions",
 ]
 
 # Both are omitted when they carry nothing: a single-task schedule has no
@@ -55,7 +52,50 @@ REQUIRED_EXEC_SUMMARY_SUBSECTION = "### Effort Sizing Criteria"
 # never saw the source report cannot rank work by a code the document never
 # defines — an opaque code with a friendlier shape.
 REQUIRED_SCALE_SUBSECTION = "### Priority & Risk Scale"
-REQUIRED_SCALE_HEADERS = ("| Priority | 기준 |", "| Risk | 기준 |")
+# A reader who opens only the summary must learn why the work happens and what
+# is true when it ends. Without these the section states scope and arithmetic
+# and never says what the work is for.
+
+# Section headings and field labels stay English literals in every language, but
+# the words around them belong to the reader. A schedule declares its language in
+# frontmatter (`lang: ko`) and is checked against that language's contract —
+# otherwise a faithful translation fails for being a translation.
+SCHEDULE_LABELS = {
+    "ko": {
+        "title_suffix": "\u2014 \uc791\uc5c5 \uc77c\uc815",
+        "meta_pattern": r"^>\s*\uc791\uc131\uc77c\s*[0-9]{4}-[0-9]{2}-[0-9]{2}",
+        "meta_hint": "> \uc791\uc131\uc77c <YYYY-MM-DD> \u00b7 \ub300\uc0c1 \uc800\uc7a5\uc18c <repo>",
+        "summary_labels": ("**\ubaa9\uc801**", "**\ub05d\ub098\uba74 \ub2ec\ub77c\uc9c0\ub294 \uac83**"),
+        "scale_headers": ("| Priority | \uae30\uc900 |", "| Risk | \uae30\uc900 |"),
+        "glance_work_column": "\uc791\uc5c5",
+    },
+    "fr": {
+        "title_suffix": "\u2014 Planning de travail",
+        "meta_pattern": r"^>\s*R\u00e9dig\u00e9 le\s*[0-9]{4}-[0-9]{2}-[0-9]{2}",
+        "meta_hint": "> R\u00e9dig\u00e9 le <YYYY-MM-DD> \u00b7 D\u00e9p\u00f4t concern\u00e9 <repo>",
+        "summary_labels": ("**Objectif**", "**Ce qui aura chang\u00e9 \u00e0 la fin**"),
+        "scale_headers": ("| Priority | Crit\u00e8re |", "| Risk | Crit\u00e8re |"),
+        "glance_work_column": "Travail",
+    },
+}
+
+
+def _schedule_language(text):
+    """The `lang:` the document declares, and any complaint about it."""
+    match = re.search(r'^lang:\s*"?([a-z]{2})"?\s*$', text, re.MULTILINE)
+    if match is None:
+        return "", [
+            "missing `lang: <code>` in frontmatter — the validator checks the "
+            "document against that language's labels (known: "
+            + ", ".join(sorted(SCHEDULE_LABELS)) + ")"
+        ]
+    lang = match.group(1)
+    if lang not in SCHEDULE_LABELS:
+        return "", [
+            "unknown `lang: " + lang + "` — known languages are "
+            + ", ".join(sorted(SCHEDULE_LABELS))
+        ]
+    return lang, []
 
 REQUIRED_TASK_FIELDS = [
     "**Category**",
@@ -183,6 +223,14 @@ def _outside_fenced_lines(text: str) -> list[str]:
     return visible
 
 
+
+def _strip_frontmatter(text: str) -> str:
+    """Body only. Frontmatter is tooling metadata the reader never renders."""
+    if not text.startswith("---\n"):
+        return text
+    end = text.find("\n---\n", 4)
+    return text[end + 5:] if end != -1 else text
+
 def _validate_format(path: Path) -> list[str]:
     if not path.exists():
         return [f"file not found: {path}"]
@@ -191,23 +239,43 @@ def _validate_format(path: Path) -> list[str]:
     lines = text.splitlines()
     visible_lines = _outside_fenced_lines(text)
     violations: list[str] = []
+    lang, lang_violations = _schedule_language(text)
+    violations.extend(lang_violations)
+    labels = SCHEDULE_LABELS.get(lang, SCHEDULE_LABELS["ko"])
 
-    # 1. Title must end with "— Work Schedule"
+    # 1. Title must end with the schedule's own suffix
     title_line = next((ln for ln in lines if ln.startswith("# ")), "")
     if not title_line:
         violations.append("missing top-level title (# …)")
-    elif not title_line.rstrip().endswith("— Work Schedule"):
+    elif not title_line.rstrip().endswith(labels["title_suffix"]):
         violations.append(
-            f'title must end with "— Work Schedule"; got: {title_line!r}'
+            f'title must end with "{labels["title_suffix"]}"; got: {title_line!r}'
         )
 
-    # 2. Metadata header lines required
-    if not re.search(r"^>\s*Generated:.*\|\s*Project:.*\|\s*Task Group:", text, re.MULTILINE):
+    # 2. One metadata line: when it was written and which repository it targets.
+    #    The schedule is shared with people who do not run okstra, so it names
+    #    neither the tool nor its task-group / task-key vocabulary.
+    if not re.search(labels["meta_pattern"], text, re.MULTILINE):
+        violations.append(f"missing `{labels['meta_hint']}` metadata line")
+    body = re.sub(r"<!--.*?-->", "", _strip_frontmatter(text), flags=re.DOTALL)
+    # A path under the run's own working tree — `.okstra/…`, or the `qa/…`
+    # scratch it holds — is a place the reader cannot open and does not own.
+    # Name the artefact instead: "계약 캡처 도구", not its path.
+    tooling_path = re.search(r"`[^`\n]*(?:\.okstra/|(?<![\w/])qa/)[^`\n]*`", body)
+    if tooling_path:
         violations.append(
-            "missing `> Generated: <…> | Project: <…> | Task Group: <…>` metadata line"
+            f"schedule cites a run-internal path {tooling_path.group(0)} — that "
+            "tree belongs to the tool, not the reader; name the artefact instead"
+        )
+    prose = re.sub(r"`[^`\n]*`", "", body)
+    leaked = re.search(
+        r"\b(okstra|task-group|Task Group|taskType|task-key|taskKey)\b", prose
+    )
+    if leaked:
+        violations.append(
+            "schedule prose names okstra or its vocabulary "
+            f"({leaked.group(1)!r}) — the reader does not run it"
         )
-    if not re.search(r"^>\s*Source:\s*okstra\b", text, re.MULTILINE):
-        violations.append("missing `> Source: okstra <mode> …` metadata line")
 
     # 3. Required sections present and in order. The optional `## Gantt Chart`
     #    sections, if present, MUST sit between Executive Summary and
@@ -264,13 +332,26 @@ def _validate_format(path: Path) -> list[str]:
             "`High` are undefined codes without it"
         )
     else:
-        for header in REQUIRED_SCALE_HEADERS:
+        for header in labels["scale_headers"]:
             if header not in text:
                 violations.append(
                     f"{REQUIRED_SCALE_SUBSECTION} requires the header literal "
                     f"{header!r}"
                 )
 
+    # 3c. The summary states purpose and end state, not just scope.
+    if "## Executive Summary" in section_positions:
+        start = section_positions["## Executive Summary"]
+        rest = "\n".join(lines[start + 1:])
+        next_h = re.search(r"^##\s", rest, re.MULTILINE)
+        summary = rest[: next_h.start()] if next_h else rest
+        for label in labels["summary_labels"]:
+            if label not in summary:
+                violations.append(
+                    f"`## Executive Summary` is missing {label!r} — the reader "
+                    "must learn why the work happens and what is true when it ends"
+                )
+
     # 4. Executive Summary subsection
     effort_heading_count = sum(
         line.rstrip() == REQUIRED_EXEC_SUMMARY_SUBSECTION
@@ -377,15 +458,15 @@ def _validate_format(path: Path) -> list[str]:
             r"^\|\s*\d+\s*\|.*$", body, re.MULTILINE
         ):
             cells = split_pipe_row(row.group(0))
-            # header: # | Task ID | Title | Category | Priority | Effort | Days | Risk
-            if len(cells) < 8:
+            # header: # | 작업 | Category | Priority | Effort | Days | Risk
+            if len(cells) < 7:
                 continue
-            priority = re.sub(r"\*+", "", cells[4]).strip()
-            effort = re.sub(r"\*+", "", cells[5]).strip()
+            priority = re.sub(r"\*+", "", cells[3]).strip()
+            effort = re.sub(r"\*+", "", cells[4]).strip()
             # `Effort` cell may contain extra hint like `L (5-15 files)`; pick the leading token
             effort_token = effort.split()[0] if effort else ""
-            risk = re.sub(r"\*+", "", cells[7]).strip()
-            task_id = cells[1]
+            risk = re.sub(r"\*+", "", cells[6]).strip()
+            task_id = cells[1]  # the work's name; ids are not printed here
             if priority and priority not in ALLOWED_PRIORITY:
                 violations.append(
                     f"At a Glance row for {task_id!r}: Priority {priority!r} "
@@ -545,25 +626,12 @@ def _validate_format(path: Path) -> list[str]:
                 break
             last_pos = pos
 
-    # Recommended Immediate Actions must be a bullet list (no numbered list,
-    # no checkboxes — this is a client-facing work plan, not an internal todo).
-    if "## Recommended Immediate Actions" in section_positions:
-        start = section_positions["## Recommended Immediate Actions"]
-        rest = "\n".join(lines[start + 1:])
-        next_h = re.search(r"^##\s", rest, re.MULTILINE)
-        body = rest[: next_h.start()] if next_h else rest
-        body = body.strip()
-        if body and not re.search(r"^-\s+\S", body, re.MULTILINE):
-            violations.append(
-                "Recommended Immediate Actions must be a markdown bullet list "
-                "(`- <action>`); numbered lists are forbidden"
-            )
-        if re.search(r"^-\s+\[[ xX]\]\s", body, re.MULTILINE):
-            violations.append(
-                "Recommended Immediate Actions must not use checkbox items "
-                "(`- [ ] …`) — schedule is a client-facing plan, not an "
-                "internal todo list"
-            )
+    # A schedule is a work plan, not a todo list: no checkbox anywhere.
+    if re.search(r"^\s*[-*]\s+\[[ xX]\]\s", _strip_frontmatter(text), re.MULTILINE):
+        violations.append(
+            "schedule uses checkbox items (`- [ ] …`) — it is a work plan, "
+            "not an internal todo list"
+        )
 
     # 14. Self-contained identifiers — opaque cross-doc codes (FC-N, UC-N,
     # M-N, A1, B2, …) must be either inlined as prose (Form A) or resolved in
@@ -593,18 +661,24 @@ def _strip_code_fences(text: str) -> str:
 
 def _extract_task_id_whitelist(text: str, section_positions: dict[str, int],
                                 lines: list[str]) -> set[str]:
-    """Pull TASK-IDs from the At a Glance table column 2."""
+    """TASK-IDs the schedule legitimately prints.
+
+    At a Glance names tasks by their work, not their id, so the ids that do
+    reach the page come from the two places that need to tell tasks apart when
+    more than one is scheduled: the Gantt row labels and the dependency graph.
+    """
     whitelist: set[str] = set()
-    if "## At a Glance" not in section_positions:
-        return whitelist
-    start = section_positions["## At a Glance"]
-    rest = "\n".join(lines[start + 1:])
-    next_h = re.search(r"^##\s", rest, re.MULTILINE)
-    body = rest[: next_h.start()] if next_h else rest
-    for row in re.finditer(r"^\|\s*\d+\s*\|.*$", body, re.MULTILINE):
-        cells = split_pipe_row(row.group(0))
-        if len(cells) >= 2 and re.fullmatch(r"[A-Z][A-Z0-9_-]*", cells[1]):
-            whitelist.add(cells[1])
+    for match in re.finditer(
+        r"^\s*([A-Z][A-Z0-9_-]*)\s+Stage\s+\d+", text, re.MULTILINE
+    ):
+        whitelist.add(match.group(1))
+    if "## Task Dependency Graph" in section_positions:
+        start = section_positions["## Task Dependency Graph"]
+        rest = "\n".join(lines[start + 1:])
+        next_h = re.search(r"^##\s", rest, re.MULTILINE)
+        body = rest[: next_h.start()] if next_h else rest
+        for token in re.findall(r"\b[A-Z][A-Z0-9_-]*\b", body):
+            whitelist.add(token)
     return whitelist
 
 
@@ -708,17 +782,17 @@ def _check_self_contained_identifiers(text: str, lines: list[str],
                 "or add a `## Glossary` section (Form B)"
             )
 
-    # Glossary placement: must sit AFTER `## Recommended Immediate Actions`.
-    if glossary_present and "## Recommended Immediate Actions" in section_positions:
-        actions_idx = section_positions["## Recommended Immediate Actions"]
-        # Re-locate glossary by line index for ordering check.
+    # Glossary placement: nothing may follow it.
+    if glossary_present:
         glossary_line_idx = next(
             (i for i, ln in enumerate(lines) if ln.rstrip() == "## Glossary"), -1
         )
-        if 0 <= glossary_line_idx <= actions_idx:
+        if glossary_line_idx >= 0 and any(
+            ln.startswith("## ") and ln.rstrip() != "## Glossary"
+            for ln in _outside_fenced_lines(text)[glossary_line_idx + 1:]
+        ):
             violations.append(
-                "`## Glossary` must be the last `##` section, placed AFTER "
-                "`## Recommended Immediate Actions`"
+                "`## Glossary` must be the last `##` section"
             )
 
     # Glossary header literal check.