okstra 0.65.0 → 0.67.0

package/docs/kr/cli.md

@@ -296,7 +296,7 @@ scripts/okstra.sh --task-type implementation-planning --workers claude,codex --p
 ```
 
 > 모든 `--*-model` 플래그는 `scripts/okstra_ctl/models.py` 의 provider 별 mapping 에 등록된 alias 만 허용합니다. 등록되지 않은 값은 `UnknownModelError` 로 즉시 거부됩니다 (manifest 의 `modelExecutionValue` 와 실제 실행값 불일치로 인한 contract-violation 을 사전에 차단). 허용값:
-> - Claude (`--lead-model` / `--claude-model` / `--report-writer-model`): `opus`, `opus-4-7`, `claude-opus-4-7`, `opus-4-6`, `claude-opus-4-6`, `sonnet`, `sonnet-4-6`, `claude-sonnet-4-6`, `haiku`, `haiku-4-5`, `claude-haiku-4-5`, `claude-haiku-4-5-20251001`
+> - Claude (`--lead-model` / `--claude-model` / `--report-writer-model`): `fable`, `fable-5`, `claude-fable-5`, `opus`, `opus-4-8`, `claude-opus-4-8`, `opus-4-7`, `claude-opus-4-7`, `opus-4-6`, `claude-opus-4-6`, `sonnet`, `sonnet-4-6`, `claude-sonnet-4-6`, `haiku`, `haiku-4-5`, `claude-haiku-4-5`, `claude-haiku-4-5-20251001`
 > - Codex (`--codex-model`): `gpt-5.5`, `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.3-codex`, `gpt-5.2`, `codex-auto-review`
 > - Gemini (`--gemini-model`): `auto`, `pro`, `gemini-3-flash-preview`, `gemini-3-pro-preview` (그리고 `gemini auto` / `gemini pro` 별칭)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.65.0",
+  "version": "0.67.0",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.65.0",
-  "builtAt": "2026-06-10T08:26:08.228Z",
+  "package": "0.67.0",
+  "builtAt": "2026-06-10T10:33:26.768Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/agents/SKILL.md

@@ -225,7 +225,7 @@ Spawn **analysis workers only** in the same turn (Phase 4 in Teams mode; Phase 5
 
 **Agent `name` on dispatch (BLOCKING — token-usage attribution depends on it).** Every analysis-worker `Agent(...)` call MUST set `name: "<workerId>-worker"` — `name: "claude-worker"` / `name: "codex-worker"` / `name: "gemini-worker"` — exactly as the report-writer dispatch sets `name: "report-writer"` ([okstra-report-writer](./skills/okstra-report-writer/SKILL.md)). The Agent harness records this `name` as `agentName` in the subagent session jsonl, and the Phase 7 token collector matches each worker's session by that `agentName` (`okstra_token_usage/collect.py`). A worker dispatched **without** `name` produces a session with no `agentName`; the collector cannot attribute it and records the worker as `source: "unavailable"` even though the session exists and is team-tagged (observed in `dev-9692` error-analysis: `claude`/`codex` workers dispatched without `name` → both `unavailable`, while the named `report-writer` collected normally). Convergence reverify dispatches keep the prefix (`<workerId>-worker-reverify-r<N>`); implementation executor/verifier variants keep `<workerId>-worker` / `<workerId>-executor`.
 
-**Agent `model:` on dispatch (BLOCKING — assignment is otherwise ignored).** The `Claude worker` `Agent(...)` call MUST set `model: "<family token of that role's modelExecutionValue>"` (`opus` / `sonnet` / `haiku`), per [okstra-team-contract](./skills/okstra-team-contract/SKILL.md) "Model Assignment Rules" #3–#4. The claude-worker definition is `model: inherit`, so omitting this parameter makes the worker silently run on the lead's model instead of its manifest assignment — the assigned-vs-actual deviation. `Codex worker` / `Gemini worker` are exempt: their CLI model is applied via the wrapper's own `--model` argument, so leave their Agent `model:` at `inherit` (rule #5).
+**Agent `model:` on dispatch (BLOCKING — assignment is otherwise ignored).** The `Claude worker` `Agent(...)` call MUST set `model: "<family token of that role's modelExecutionValue>"` (`fable` / `opus` / `sonnet` / `haiku`), per [okstra-team-contract](./skills/okstra-team-contract/SKILL.md) "Model Assignment Rules" #3–#4. The claude-worker definition is `model: inherit`, so omitting this parameter makes the worker silently run on the lead's model instead of its manifest assignment — the assigned-vs-actual deviation. `Codex worker` / `Gemini worker` are exempt: their CLI model is applied via the wrapper's own `--model` argument, so leave their Agent `model:` at `inherit` (rule #5).
 
 The no-`team_name` fallback (Phase 5) is only legal when team-state's `teamCreate.status` is `"error"` for this run. If `teamCreate` is missing or `attempted: false`, the correct action when an Agent dispatch is rejected for a missing team is to GO BACK to Phase 3 and call `TeamCreate` — never to strip `team_name` and continue.
 

package/runtime/prompts/wizard/prompts.ko.json

@@ -3,10 +3,10 @@
   "locale": "ko",
   "steps": {
     "task_pick": {
-      "label": "어느 task?",
+      "label": "어느 task? (남은 작업 최신순 추천)",
       "echo_template": "task: {value}",
       "options": {
-        "__new__": "Start a brand-new task",
+        "__new__": "직접 입력 (새 작업 또는 목록에 없는 task)",
         "_LATEST_SUFFIX": "  (latest)"
       }
     },
@@ -80,9 +80,19 @@
       "label": "Task type?",
       "echo_template": "task-type: {value}",
       "options": {
-        "_RECOMMENDED_SUFFIX": " (recommended)"
+        "_RECOMMENDED_SUFFIX": " (recommended)",
+        "_RERUN_SUFFIX": " (현재 phase 재실행)",
+        "_NEXT_SUFFIX": " (다음 단계)",
+        "__free_input__": "직접 입력"
+      },
+      "echo_variants": {
+        "free_input": "task-type: (직접 입력)"
       }
     },
+    "task_type_text": {
+      "label": "Task type? (입력 가능: requirements-discovery, improvement-discovery, error-analysis, implementation-planning, implementation, final-verification, release-handoff)",
+      "echo_template": "task-type: {value}"
+    },
     "brief_keep": {
       "label": "기존 brief 경로 [{existing_brief_path}] 를 유지할까요?",
       "echo_template": "brief: {value}",

package/runtime/python/okstra_ctl/models.py

@@ -8,7 +8,12 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 CLAUDE_MAPPING = {
+    "fable": ("fable", "fable"),
+    "fable-5": ("fable-5", "claude-fable-5"),
+    "claude-fable-5": ("fable-5", "claude-fable-5"),
     "opus": ("opus", "opus"),
+    "opus-4-8": ("opus-4-8", "claude-opus-4-8"),
+    "claude-opus-4-8": ("opus-4-8", "claude-opus-4-8"),
     "opus-4-7": ("opus-4-7", "claude-opus-4-7"),
     "claude-opus-4-7": ("opus-4-7", "claude-opus-4-7"),
     "opus-4-6": ("opus-4-6", "claude-opus-4-6"),

package/runtime/python/okstra_ctl/render_final_report.py

@@ -358,7 +358,8 @@ def _enforce_schema(data: dict) -> None:
 # 구체버전 계열로 돌았는지" 가독성만 준다. CLI 가 실제 고른 버전과 다를 수
 # 있으나 표시이므로 실행에는 무해하다. 새 버전이 나오면 여기만 갱신한다.
 _DISPLAY_CONCRETE_CLAUDE = {
-    "opus": "claude-opus-4-7",
+    "fable": "claude-fable-5",
+    "opus": "claude-opus-4-8",
     "sonnet": "claude-sonnet-4-6",
     "haiku": "claude-haiku-4-5",
 }

package/runtime/python/okstra_ctl/wizard.py

@@ -49,6 +49,7 @@ from okstra_ctl.workers import (
     resolve_profile_workers,
     validate_workers_against_profile,
 )
+from okstra_ctl.workflow import PHASE_SEQUENCE
 from okstra_ctl import worktree_registry
 from okstra_ctl.worktree import (
     is_git_work_tree,
@@ -90,13 +91,18 @@ _STAGE_SCOPED_TASK_TYPES = ("implementation", "final-verification")
 CANONICAL_BASE_REFS = ["main", "dev", "staging", "preprod", "prod"]
 BASE_REF_FREE_INPUT_TOKEN = "__free_input__"
 
-CLAUDE_MODEL_OPTIONS = ["default", "opus", "sonnet", "haiku"]
+CLAUDE_MODEL_OPTIONS = ["default", "fable", "opus", "sonnet", "haiku"]
 CODEX_MODEL_OPTIONS = ["default", "gpt-5.5", "gpt-5.4", "gpt-5.4-mini"]
 GEMINI_MODEL_OPTIONS = ["default", "gemini-3-pro-preview", "gemini-3-flash-preview", "auto"]
 
 # special pick value: start a brand-new task
 TASK_PICK_NEW_TOKEN = "__new__"
 
+# AskUserQuestion renders at most 4 options per question; the last slot is
+# always reserved for the direct-input option, so recommendation lists from
+# dynamic sources (catalog, manifest) are capped at 3.
+_RECOMMENDATION_CAP = 3
+
 # Pick-vs-free-text tokens shared by suggestion-aware prompts.
 PICK_USE_SUGGESTED = "__use_suggested__"
 PICK_TYPE_CUSTOM = "__free_input__"
@@ -220,6 +226,7 @@ S_TASK_GROUP_TEXT = "task_group_text"
 S_TASK_ID = "task_id"
 S_TASK_ID_TEXT = "task_id_text"
 S_TASK_TYPE = "task_type"
+S_TASK_TYPE_TEXT = "task_type_text"
 S_BRIEF_KEEP = "brief_keep"
 S_BRIEF_PATH_PICK = "brief_path_pick"
 S_BRIEF_PATH = "brief_path"
@@ -788,12 +795,15 @@ def _build_task_pick(state: WizardState) -> Prompt:
     latest = read_latest_task(project_root) or {}
     latest_key = latest.get("taskKey") or ""
     latest_suffix = t["options"].get("_LATEST_SUFFIX", "")
+    remaining = [e for e in tasks if (e.get("workStatus") or "") != "done"]
     options: list[Option] = []
-    for entry in tasks[:16]:
+    for entry in remaining[:_RECOMMENDATION_CAP]:
         key = entry.get("taskKey") or ""
         ttype = entry.get("taskType") or ""
-        phase = (entry.get("workflow") or {}).get("currentPhase") or ttype
-        nxt = (entry.get("workflow") or {}).get("nextRecommendedPhase") or ""
+        # catalog entries are flat (render_task_catalog_discovery) — there is
+        # no nested "workflow" object here, unlike task-manifest.json.
+        phase = entry.get("currentPhase") or ttype
+        nxt = entry.get("nextRecommendedPhase") or ""
         suffix = latest_suffix if key == latest_key else ""
         label = f"{key}  ·  {phase}  ·  next: {nxt}{suffix}"
         options.append(_opt(value=key, label=label))
@@ -838,7 +848,9 @@ def _submit_task_pick(state: WizardState, value: str) -> Optional[str]:
     return f"task: {value}"
 
 
-def _suggest_recent_task_groups(state: WizardState, limit: int = 2) -> list[str]:
+def _suggest_recent_task_groups(
+    state: WizardState, limit: int = _RECOMMENDATION_CAP
+) -> list[str]:
     """프로젝트 catalog 에서 최근 task-group 후보를 limit 개까지 반환."""
     if not state.project_root:
         return []
@@ -856,7 +868,9 @@ def _suggest_recent_task_groups(state: WizardState, limit: int = 2) -> list[str]
     return seen
 
 
-def _suggest_recent_task_ids(state: WizardState, limit: int = 2) -> list[str]:
+def _suggest_recent_task_ids(
+    state: WizardState, limit: int = _RECOMMENDATION_CAP
+) -> list[str]:
     """현재 task_group 내의 최근 task-id 후보를 limit 개까지 반환."""
     if not state.project_root or not state.task_group:
         return []
@@ -925,7 +939,7 @@ def _build_task_group(state: WizardState) -> Prompt:
             echo_template=t["echo_template"],
         )
     # suggestion 이 없으면 catalog 의 최근 task-group 을 후보로 노출 + 직접 입력
-    recent = _suggest_recent_task_groups(state, limit=2)
+    recent = _suggest_recent_task_groups(state)
     t = _p(state.workspace_root, "task_group_no_suggestion")
     recent_prefix = t.get("recent_label_prefix", "")
     options: list[Option] = []
@@ -999,7 +1013,7 @@ def _build_task_id(state: WizardState) -> Prompt:
             label=t["label"], options=options,
             echo_template=t["echo_template"],
         )
-    recent = _suggest_recent_task_ids(state, limit=2)
+    recent = _suggest_recent_task_ids(state)
     t = _p(state.workspace_root, "task_id_no_suggestion")
     recent_prefix = t.get("recent_label_prefix", "")
     options: list[Option] = []
@@ -1058,48 +1072,88 @@ def _submit_task_id_text(state: WizardState, value: str) -> Optional[str]:
     return f"task-id: {state.task_id}"
 
 
-def _existing_task_next_phase(state: WizardState) -> str:
-    """새 task 로 시작했더라도 입력한 task-key 가 이미 존재하면(=사실상 이어가기)
-    그 기존 manifest 의 nextRecommendedPhase 를 반환한다. 없으면 ''.
+def _existing_task_workflow(state: WizardState) -> dict:
+    """현재 task-key 가 이미 존재하면 그 manifest 의 workflow dict 를 반환한다.
 
-    사용자가 picker 에서 기존 task-key 를 고르지 않고 new-task 흐름으로 같은
-    task-group/task-id 를 다시 입력한 경우에도 직전 phase 의 추천이 끊기지 않게
-    하는 안전장치."""
+    picker 로 기존 task 를 고른 경우뿐 아니라, new-task 흐름으로 같은
+    task-group/task-id 를 다시 입력한 경우(=사실상 이어가기)에도 직전 phase
+    기반 추천이 끊기지 않게 하는 안전장치. 없으면 {}."""
     if not (state.project_id and state.task_group and state.task_id):
-        return ""
+        return {}
     key = f"{state.project_id}:{state.task_group}:{state.task_id}"
     root = find_task_root(Path(state.project_root), key)
     if root is None:
-        return ""
+        return {}
     workflow = (read_task_manifest(root) or {}).get("workflow") or {}
-    nxt = workflow.get("nextRecommendedPhase") or ""
-    return nxt if isinstance(nxt, str) else ""
+    return workflow if isinstance(workflow, dict) else {}
+
+
+def _phase_after(task_type: str) -> str:
+    """라이프사이클(PHASE_SEQUENCE) 상 task_type 바로 다음 단계. 없으면 ''."""
+    try:
+        idx = PHASE_SEQUENCE.index(task_type)
+    except ValueError:
+        return ""
+    return PHASE_SEQUENCE[idx + 1] if idx + 1 < len(PHASE_SEQUENCE) else ""
+
+
+def _recent_task_types(state: WizardState) -> list[str]:
+    """catalog 최신순으로 이 프로젝트에서 최근 사용된 task-type 목록(중복 제거)."""
+    if not state.project_root:
+        return []
+    try:
+        tasks = list_project_tasks(Path(state.project_root))
+    except (OSError, StateError):
+        return []
+    out: list[str] = []
+    for entry in tasks:
+        tt = entry.get("taskType") or ""
+        if tt and tt not in out:
+            out.append(tt)
+    return out
 
 
 def _build_task_type(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "task_type")
     recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
+    rerun_suffix = t["options"].get("_RERUN_SUFFIX", "")
+    next_suffix = t["options"].get("_NEXT_SUFFIX", "")
+    description_by_type = dict(TASK_TYPES)
     options: list[Option] = []
-    recommended = state.task_type if not state.is_new_task else ""
-    if not recommended and state.is_new_task:
-        recommended = _existing_task_next_phase(state)
-    seen: list[str] = []
-    if recommended and recommended in TASK_TYPE_VALUES:
-        d = dict(TASK_TYPES)[recommended]
-        options.append(_opt(recommended, f"{recommended}{recommended_suffix}", d))
-        seen.append(recommended)
-    for tt, desc in TASK_TYPES:
-        if tt in seen:
-            continue
-        options.append(_opt(tt, tt, desc))
+
+    def add(task_type: str, suffix: str = "") -> None:
+        if task_type not in description_by_type:
+            return
+        if any(o.value == task_type for o in options):
+            return
+        if len(options) >= _RECOMMENDATION_CAP:
+            return
+        options.append(_opt(task_type, f"{task_type}{suffix}",
+                            description_by_type[task_type]))
+
+    workflow = _existing_task_workflow(state)
+    recommended = state.task_type or workflow.get("nextRecommendedPhase") or ""
+    if not recommended and not workflow:
+        recommended = TASK_TYPE_VALUES[0]
+    add(recommended, recommended_suffix)
+    add(workflow.get("currentPhase") or "", rerun_suffix)
+    add(_phase_after(recommended), next_suffix)
+    for tt in _recent_task_types(state):
+        add(tt)
+    for tt in TASK_TYPE_VALUES:
+        add(tt)
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
     return Prompt(step=S_TASK_TYPE, kind="pick",
                   label=t["label"], options=options,
                   echo_template=t["echo_template"])
 
 
-def _submit_task_type(state: WizardState, value: str) -> Optional[str]:
+def _apply_task_type(state: WizardState, value: str) -> str:
     if value not in TASK_TYPE_VALUES:
-        raise WizardError(f"unknown task-type: {value!r}")
+        raise WizardError(
+            f"unknown task-type: {value!r} "
+            f"(expected one of: {', '.join(TASK_TYPE_VALUES)})"
+        )
     state.task_type = value
     state.profile_workers = _load_profile_workers(
         Path(state.workspace_root), value
@@ -1113,6 +1167,27 @@ def _submit_task_type(state: WizardState, value: str) -> Optional[str]:
     return f"task-type: {value}"
 
 
+def _submit_task_type(state: WizardState, value: str) -> Optional[str]:
+    # PICK_TYPE_CUSTOM leaves task_type empty while S_TASK_TYPE gets marked
+    # answered — that combination is what gates S_TASK_TYPE_TEXT on.
+    if value == PICK_TYPE_CUSTOM:
+        state.task_type = ""
+        t = _p(state.workspace_root, "task_type")
+        return t["echo_variants"]["free_input"]
+    return _apply_task_type(state, value)
+
+
+def _build_task_type_text(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "task_type_text")
+    return Prompt(step=S_TASK_TYPE_TEXT, kind="text",
+                  label=t["label"],
+                  echo_template=t["echo_template"])
+
+
+def _submit_task_type_text(state: WizardState, value: str) -> Optional[str]:
+    return _apply_task_type(state, value.strip())
+
+
 def _build_brief_keep(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "brief_keep",
            existing_brief_path=state.existing_brief_path)
@@ -2216,6 +2291,7 @@ STEPS: list[Step] = [
                  (s.is_new_task is True and bool(s.task_group))
                  or (s.is_new_task is False
                      and S_TASK_TYPE in s.answered
+                     and bool(s.task_type)
                      and (s.keep_existing_brief is False
                           or not s.existing_brief_path))
              )
@@ -2250,11 +2326,19 @@ STEPS: list[Step] = [
          build=_build_task_type, submit=_submit_task_type,
          owns=("task_type", "profile_workers", "profile_optional_workers",
                "reuse_worktree")),
+    Step(S_TASK_TYPE_TEXT,
+         applies=lambda s: (S_TASK_TYPE in s.answered
+                            and not s.task_type
+                            and S_TASK_TYPE_TEXT not in s.answered),
+         build=_build_task_type_text, submit=_submit_task_type_text,
+         owns=("task_type", "profile_workers", "profile_optional_workers",
+               "reuse_worktree")),
     Step(S_BRIEF_KEEP,
          applies=lambda s: (not s.is_new_task
                             and bool(s.existing_brief_path)
                             and s.keep_existing_brief is None
-                            and S_TASK_TYPE in s.answered),
+                            and S_TASK_TYPE in s.answered
+                            and bool(s.task_type)),
          build=_build_brief_keep, submit=_submit_brief_keep,
          owns=("keep_existing_brief",)),
     Step(S_BASE_REF_PICK,

package/runtime/python/okstra_token_usage/pricing.py

@@ -4,9 +4,9 @@ Pricing is matched by substring against the model id recorded in the session
 transcript, so keys must reflect the *actual* model id form emitted by each
 provider:
 
-  * Anthropic — `claude-opus-4-*`, `claude-sonnet-4-*`, `claude-haiku-4-5-*`,
-    `claude-3-5-sonnet-*`, `claude-3-5-haiku-*`, `claude-3-opus-*`,
-    `claude-3-haiku-*`.
+  * Anthropic — `claude-fable-5*`, `claude-opus-4-*`, `claude-sonnet-4-*`,
+    `claude-haiku-4-5-*`, `claude-3-5-sonnet-*`, `claude-3-5-haiku-*`,
+    `claude-3-opus-*`, `claude-3-haiku-*`.
   * OpenAI / Codex — `gpt-5*`, `gpt-4o*`, `gpt-4*`.
   * Google / Gemini — `gemini-2.5-pro*`, `gemini-2.5-flash*`, `gemini-2.0-flash*`.
 
@@ -45,7 +45,11 @@ CLAUDE_PRICING = {
     "3-sonnet":   (3.0, 3.75, 0.30, 15.0),     # legacy 3 Sonnet
     "3-haiku":    (0.25, 0.30, 0.03, 1.25),    # Haiku 3
 
+    # Claude Fable 5 (tier above Opus).
+    "fable-5":    (10.0, 12.5, 1.0, 50.0),     # Fable 5 (cache prices derived from ratios)
+
     # Claude 4 point releases (explicit so future divergence is easy to see).
+    "opus-4-8":   (5.0, 6.25, 0.50, 25.0),     # Opus 4.8 (cache prices derived from ratios)
     "opus-4-7":   (5.0, 6.25, 0.50, 25.0),     # Opus 4.7 (cache prices derived from ratios)
     "opus-4-6":   (5.0, 6.25, 0.50, 25.0),     # Opus 4.6 (legacy; pricing matches 4.7 per Anthropic)
     "sonnet-4-6": (3.0, 3.75, 0.30, 15.0),     # Sonnet 4.6 (cache prices derived from ratios)

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

@@ -118,8 +118,8 @@ Repeat until `next.kind == "done"`:
 
 That is the entire interactive flow. The wizard handles:
 
-- new-vs-existing task split, task-group / task-id slug validation,
-- task-type pick (with `nextRecommendedPhase` surfaced as recommended for existing tasks),
+- new-vs-existing task split (남은 작업 — `workStatus != done` — 최신순 3개 추천 + 직접 입력), task-group / task-id slug validation (각각 최근 후보 3개 추천 + 직접 입력),
+- task-type pick (추천 3개 — `nextRecommendedPhase` recommended / 현재 phase 재실행 / 라이프사이클 다음 단계 — + 직접 입력; 직접 입력은 후속 `text` 단계에서 전체 task-type 화이트리스트로 검증),
 - brief path after task-group selection (same-group `.okstra/briefs/<task-group>/**/*.md` candidates first, direct input last; `유지 / 변경` for existing tasks),
 - base-ref pick + git rev-parse validation (skipped when reusing an active worktree),
 - `implementation`-only sub-flow: approved-plan path (frontmatter `approved: true` check) + stage pick (`auto` = 의존성 충족된 가장 빠른 미완료 stage, 또는 특정 stage 번호) + executor pick,

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

@@ -56,15 +56,15 @@ Subsequent `okstra <subcmd>` calls self-bootstrap their Python path, so this ski
 
 This skill performs cross-task synthesis (multi-task classification, dependency reasoning, phase placement, Gantt/timeline assembly) which benefits substantially from Opus-class reasoning. The frontmatter `model: opus` field above instructs supporting Claude Code harness versions to switch automatically; if the harness ignores it, this gate catches the case explicitly.
 
-1. Inspect the active session model. The model is shown in the status line, accessible via `/model`, and embedded in the runtime context as the model name (e.g. `claude-opus-4-7`, `claude-sonnet-4-6`, `claude-haiku-4-5-*`).
-2. If the active model is **Opus-class** (`claude-opus-*`): proceed to Step 1.
+1. Inspect the active session model. The model is shown in the status line, accessible via `/model`, and embedded in the runtime context as the model name (e.g. `claude-fable-5`, `claude-opus-4-7`, `claude-sonnet-4-6`, `claude-haiku-4-5-*`).
+2. If the active model is **Opus-class or above** (`claude-opus-*`, `claude-fable-*`): proceed to Step 1.
 3. If the active model is **Sonnet or Haiku-class**: STOP and output the following message verbatim, then wait for user response:
    ```
    okstra-schedule는 Opus-class 모델에서 실행하는 것을 권장합니다 (현재: <active-model>).
    /model opus 로 전환 후 다시 호출하시거나, 'sonnet으로 진행' 이라고 명시하시면 그대로 실행합니다.
    ```
 4. If the user explicitly insists on the lower model ("sonnet으로 진행", "그대로 진행", "force", or similar): proceed to Step 1, but prepend a single-line warning at the top of the generated schedule file: `> ⚠️ Generated with <model> (not Opus). Cross-task synthesis quality may be reduced.`
-5. Skip this gate ONLY when the harness has clearly enforced `model: opus` from the frontmatter — verifiable by the active model already being Opus-class without manual switching.
+5. Skip this gate ONLY when the harness has clearly enforced `model: opus` from the frontmatter — verifiable by the active model already being Opus-class or above without manual switching.
 
 ### Step 1: Resolve task-group and collect tasks
 

package/runtime/skills/okstra-team-contract/SKILL.md

@@ -38,7 +38,7 @@ okstra tasks are always operated using the `Claude lead` + required worker team
 1. `resultContract.requiredWorkerRoles` in `task-manifest.json` (and the lead model metadata) is the canonical source. There is no role-level fallback — a missing assignment is a manifest defect, not a license to invent one.
 2. If `modelExecutionValue` differs from `model`, use `modelExecutionValue` during execution.
 3. **Spawn-time enforcement for in-process Claude subagents (BLOCKING).** `Claude worker` and `Report writer worker` are in-process Claude subagents whose agent definitions declare `model: inherit` (`agents/workers/claude-worker.md`, `agents/workers/report-writer-worker.md`). `inherit` follows the **lead's** runtime model, NOT the role's assignment — so an opus assignment silently runs on a sonnet lead. To make the assignment binding (not merely declared), lead MUST pass an explicit `model:` parameter on every `Agent(...)` dispatch for these two roles, derived from that role's `modelExecutionValue`. The dispatch `model:` parameter overrides the `inherit` frontmatter; the frontmatter remains only as the fallback when no parameter is supplied. Omitting `model:` on a Claude-side dispatch is a contract violation that reproduces the assigned-vs-actual model deviation.
-4. **`modelExecutionValue` → Agent `model:` family token.** The Agent tool's `model` parameter accepts family tokens only — `opus` / `sonnet` / `haiku` (an exact version such as `claude-opus-4-7` is NOT a valid value). Map by prefix: a `modelExecutionValue` of `opus*` / `claude-opus*` → `"opus"`, `sonnet*` / `claude-sonnet*` → `"sonnet"`, `haiku*` / `claude-haiku*` → `"haiku"`. This enforces the assignment at **family granularity** (opus vs sonnet vs haiku); the exact version within a family is still inherited from the lead session and cannot be pinned via this parameter.
+4. **`modelExecutionValue` → Agent `model:` family token.** The Agent tool's `model` parameter accepts family tokens only — `fable` / `opus` / `sonnet` / `haiku` (an exact version such as `claude-opus-4-7` is NOT a valid value). Map by prefix: a `modelExecutionValue` of `fable*` / `claude-fable*` → `"fable"`, `opus*` / `claude-opus*` → `"opus"`, `sonnet*` / `claude-sonnet*` → `"sonnet"`, `haiku*` / `claude-haiku*` → `"haiku"`. This enforces the assignment at **family granularity** (fable vs opus vs sonnet vs haiku); the exact version within a family is still inherited from the lead session and cannot be pinned via this parameter.
 5. **Codex / Gemini wrappers are out of scope for the Agent `model:` rule.** `Codex worker` / `Gemini worker` subagents are Claude wrappers that shell out to an external CLI; the role's `modelExecutionValue` is already applied via the CLI's own `--model <modelExecutionValue>` argument (see `agents/workers/_cli-wrapper-template.md`). The Agent `model:` parameter for these wrappers would only set the wrapper's own orchestration model, not the external CLI's model — leave it at `inherit` and do NOT map it from `modelExecutionValue`.
 
 ### Dynamic Worker Role Determination