okstra 0.183.2 → 0.185.0

package/runtime/python/okstra_ctl/user_response.py

@@ -954,12 +954,15 @@ def list_awaiting_tasks(home: Path, project_id: str, limit: int) -> list[dict]:
 # `§x.y` is a full-reading-copy heading and is not a record coordinate.
 # `path.ext:line` is a source pointer the record does not define.
 _SECTION_REF_RE = re.compile(r"§[\d.]+|[A-Z]{1,4}-\d+|[\w./-]+\.\w+:\d+")
+_PATH_LINE_RE = re.compile(r"[\w./-]+\.\w+:\d+")
 _ID_TOKEN_RE = re.compile(r"^[A-Z]{1,4}-\d+$")
+_PLAN_ITEM_ID_RE = re.compile(r"^P-")
 _ROW_DEFINITION_KEYS = (
     "statement",
     "summary",
     "item",
     "title",
+    "subject",
     "check",
     "action",
     "evidence",
@@ -1992,6 +1995,138 @@ def _option_view(option: Mapping[str, Any], index: int) -> list[str]:
     ]
 
 
+def _option_probe_texts(options: list[Any]) -> list[str]:
+    texts: list[str] = []
+    for option in options:
+        if not isinstance(option, Mapping):
+            continue
+        texts.extend(
+            str(option.get(key) or "")
+            for key in ("answer", "rationale", "addedWork", "directionChange")
+        )
+    return texts
+
+
+def _row_probe_texts(row: Mapping[str, Any]) -> list[str]:
+    return [
+        str(row.get("statement") or ""),
+        str(row.get("expected_form") or ""),
+        *_option_probe_texts(list(row.get("options") or [])),
+    ]
+
+
+def _path_line_refs(*texts: str) -> list[str]:
+    found: list[str] = []
+    seen: set[str] = set()
+    for text in texts:
+        for match in _PATH_LINE_RE.findall(text or ""):
+            if match not in seen:
+                seen.add(match)
+                found.append(match)
+    return found
+
+
+def _why_asked(row: Mapping[str, Any]) -> str:
+    approval = row.get("approval_context") or {}
+    if not isinstance(approval, Mapping):
+        return "not stated in the report"
+    unblock = str(approval.get("unblockCondition") or "").strip()
+    if unblock:
+        return unblock
+    classification = str(approval.get("classification") or "").strip()
+    return classification or "not stated in the report"
+
+
+def _linked_plan_items(
+    record: dict[str, Any] | None, clarification_id: str
+) -> list[dict[str, str]]:
+    if record is None:
+        return []
+    linked: list[dict[str, str]] = []
+    seen: set[str] = set()
+
+    def walk(node: object) -> None:
+        if isinstance(node, dict):
+            row_id = node.get("id")
+            refs = node.get("clarificationRefs") or []
+            if (
+                isinstance(row_id, str)
+                and _PLAN_ITEM_ID_RE.match(row_id)
+                and isinstance(refs, list)
+                and clarification_id in refs
+                and row_id not in seen
+            ):
+                seen.add(row_id)
+                linked.append({
+                    "id": row_id,
+                    "definition": _row_definition(node) or "not stated in the report",
+                })
+            for value in node.values():
+                walk(value)
+        elif isinstance(node, list):
+            for item in node:
+                walk(item)
+
+    walk(record)
+    return linked
+
+
+def _format_ref_list(label: str, items: list[str]) -> list[str]:
+    if not items:
+        return [f"{label}: none"]
+    return [f"{label}:", *(f"- {item}" for item in items)]
+
+
+def _format_open_row_view(
+    row: Mapping[str, Any],
+    record: dict[str, Any] | None,
+    markdown_text: str,
+    response: UserResponseEntry | None,
+) -> list[str]:
+    item = row["item"]
+    probe = _row_probe_texts(row)
+    refs = sorted(set(_SECTION_REF_RE.findall(" ".join(probe))))
+    resolved = (
+        resolve_refs_from_record(record, refs)
+        if record is not None
+        else resolve_refs(markdown_text, refs)
+    )
+    lines = [
+        "",
+        f"[{item.row_id}]",
+        f"Kind: {item.kind}",
+        f"Blocks: {item.blocks}",
+        f"Report status: {item.status}",
+        f"Question: {row['statement']}",
+        f"Expected form: {row['expected_form']}",
+        f"Current response: {response.value if response else 'none'}",
+        f"Current disposition: {response.disposition if response else 'none'}",
+        f"Why asked: {_why_asked(row)}",
+        "Options:",
+    ]
+    approval = row.get("approval_context") or {}
+    if isinstance(approval, Mapping) and approval:
+        lines.extend([
+            f"Approval classification: {approval.get('classification', '')}",
+            f"Approval unblock condition: {approval.get('unblockCondition', '')}",
+            f"Approval recommended disposition: {approval.get('recommendedDisposition', '')}",
+        ])
+    for index, option in enumerate(row["options"], start=1):
+        lines.extend(_option_view(option, index))
+    linked = _linked_plan_items(record, item.row_id)
+    lines.extend(_format_ref_list(
+        "Linked plan items",
+        [f"{plan['id']}: {plan['definition']}" for plan in linked],
+    ))
+    lines.extend(_format_ref_list("Cited artifacts", _path_line_refs(*probe)))
+    lines.append("Context:")
+    lines.extend(
+        f"- {ref['ref']}: {ref['definition'] or 'not stated in the report'}"
+        for ref in resolved
+    )
+    return lines
+
+
 def format_show_view(report_path: Path, project_root: Path) -> str:
     context = _validate_owned_report_context(
         report_path, expected_project_root=project_root
@@ -1999,6 +2134,10 @@ def format_show_view(report_path: Path, project_root: Path) -> str:
     rows, record = _all_report_rows(context.report_path)
     state = _existing_sidecar_state(context.sidecar_path)
     current = {entry.response_id: entry for entry in state.entries}
+    markdown_text = (
+        "" if record is not None
+        else context.markdown_path.read_text(encoding="utf-8")
+    )
     lines = [
         "USER RESPONSE REPORT",
         f"Report: {context.report_path}",
@@ -2015,51 +2154,22 @@ def format_show_view(report_path: Path, project_root: Path) -> str:
     if candidates:
         lines.append("Plan option candidates:")
         for index, candidate in enumerate(candidates, start=1):
+            current_pick = (
+                state.plan_decision is not None
+                and state.plan_decision.implementation_option == candidate
+            )
             lines.extend([
                 f"Plan option {index}: {candidate}",
                 f"  Recommended: {'yes' if candidate == recommended_name else 'no'}",
-                "  Current decision: "
-                f"{'yes' if state.plan_decision and state.plan_decision.implementation_option == candidate else 'no'}",
+                f"  Current decision: {'yes' if current_pick else 'no'}",
             ])
     for row in rows:
         item = row["item"]
         if item.status not in {"open", "answered"} or item.row_id in current:
             continue
-        refs = sorted(set(_SECTION_REF_RE.findall(
-            row["statement"] + " " + row["expected_form"]
-        )))
-        resolved = (
-            resolve_refs_from_record(record, refs)
-            if record is not None
-            else resolve_refs(context.markdown_path.read_text(encoding="utf-8"), refs)
-        )
-        response = current.get(item.row_id)
-        lines.extend([
-            "",
-            f"[{item.row_id}]",
-            f"Kind: {item.kind}",
-            f"Blocks: {item.blocks}",
-            f"Report status: {item.status}",
-            f"Question: {row['statement']}",
-            f"Expected form: {row['expected_form']}",
-            f"Current response: {response.value if response else 'none'}",
-            f"Current disposition: {response.disposition if response else 'none'}",
-            "Options:",
-        ])
-        approval = row.get("approval_context") or {}
-        if approval:
-            lines.extend([
-                f"Approval classification: {approval.get('classification', '')}",
-                f"Approval unblock condition: {approval.get('unblockCondition', '')}",
-                f"Approval recommended disposition: {approval.get('recommendedDisposition', '')}",
-            ])
-        for index, option in enumerate(row["options"], start=1):
-            lines.extend(_option_view(option, index))
-        lines.append("Context:")
-        lines.extend(
-            f"- {ref['ref']}: {ref['definition'] or 'not stated in the report'}"
-            for ref in resolved
-        )
+        lines.extend(_format_open_row_view(
+            row, record, markdown_text, current.get(item.row_id),
+        ))
     return "\n".join(lines) + "\n"
 
 

package/runtime/python/okstra_ctl/wizard.py

@@ -1231,17 +1231,6 @@ def _wizard_state_from_json(payload: dict[str, Any]) -> WizardState:
     if version != 2:
         state.execution_identity_version = 2
         _convert_v1_provider_selections(state, payload)
-        # v1 은 리더 확인 칸이 없었다. 변환 재개 시 다시 묻지 않는다.
-        if (
-            state.host_entry_mode == "current-session"
-            and _LEADER_SESSION_STEP not in state.answered
-        ):
-            state.answered.append(_LEADER_SESSION_STEP)
-        if (
-            state.host_entry_mode == "current-session"
-            and _LEADER_SESSION_STEP not in state.role_selection_order
-        ):
-            state.role_selection_order.insert(0, _LEADER_SESSION_STEP)
     return state
 
 
@@ -1281,13 +1270,8 @@ def _role_model_prompt_id(role: str, ordinal: int) -> str:
     return f"role-model:{role}:{ordinal}"
 
 
-_LEADER_SESSION_STEP = "leader-session"
-
-
 def _is_role_selection_step(step_id: str) -> bool:
-    return step_id == _LEADER_SESSION_STEP or step_id.startswith(
-        ("role-count:", "role-model:", "role-add:")
-    )
+    return step_id.startswith(("role-count:", "role-model:", "role-add:"))
 
 
 def _selected_role_count(
@@ -1320,36 +1304,6 @@ def _selectable_static_requirements(
     return tuple(requirements)
 
 
-def _leader_session_prompt(state: WizardState) -> Prompt:
-    """current-session 리더 칸: 모델/effort 표시만 하고 role_models 에 쓰지 않는다."""
-    attestation = _host_session_context(state).current_model
-    model_ref = (
-        attestation.normalized_model_ref
-        or attestation.observed_model
-        or "current-session"
-    )
-    steps = _load_wizard_root(state.workspace_root)["steps"]
-    raw = steps.get("leader_session") or {}
-    effort_suffix = ""
-    if attestation.effort:
-        effort_template = raw.get("effort_suffix", " · effort {effort}")
-        effort_suffix = effort_template.format(effort=attestation.effort)
-    prompt = _p(
-        state.workspace_root,
-        "leader_session",
-        model_ref=model_ref,
-        effort_suffix=effort_suffix,
-    )
-    continue_label = prompt["options"].get("continue", "계속")
-    return Prompt(
-        step=_LEADER_SESSION_STEP,
-        kind="pick",
-        label=prompt["label"],
-        options=[_opt("continue", continue_label)],
-        echo_template=prompt["echo_template"],
-    )
-
-
 def _count_prompt(
     state: WizardState,
     requirement: RoleRequirement,
@@ -1777,13 +1731,6 @@ def next_role_prompt(state: WizardState) -> Prompt | None:
     if not _role_selection_enabled(state) or not _identity_ready(state):
         return None
     state.use_defaults = False
-    # current-session: 리더는 읽기 전용 확인 칸만 먼저 보여 준다.
-    if (
-        state.host_entry_mode == "current-session"
-        and _LEADER_SESSION_STEP not in state.answered
-        and _LEADER_SESSION_STEP not in state.role_selection_order
-    ):
-        return _leader_session_prompt(state)
     profile = _load_role_profile_for_state(state)
     for requirement in profile.roles:
         # 필수 수량: min < max 이고 min > 0 일 때만.
@@ -1884,11 +1831,6 @@ def _validate_submitted_role_model(
 
 
 def _submit_role_prompt(state: WizardState, prompt: Prompt, value: str) -> str:
-    if prompt.step == _LEADER_SESSION_STEP:
-        if value != "continue":
-            raise WizardError("leader session step accepts only 'continue'")
-        # role_models["leader"] 에 쓰지 않는다 — 현재 세션 모델을 그대로 쓴다.
-        return "leader-session: continue"
     if prompt.step.startswith("role-count:"):
         role = prompt.step.split(":", 1)[1]
         profile = _load_role_profile_for_state(state)
@@ -2041,9 +1983,11 @@ def _p(workspace_root: str, step_id: str, **vars: str) -> dict:
         raise WizardError(f"unknown wizard step_id: {step_id!r}")
     label_template = raw.get("label", "")
     fv_label_template = raw.get("label_final_verification", "")
+    unlinked_template = raw.get("label_unlinked", "")
     try:
         label = label_template.format(**vars)
         label_final_verification = fv_label_template.format(**vars)
+        label_unlinked = unlinked_template.format(**vars)
     except KeyError as exc:
         missing = exc.args[0] if exc.args else "<unknown>"
         raise WizardError(
@@ -2052,6 +1996,7 @@ def _p(workspace_root: str, step_id: str, **vars: str) -> dict:
     return {
         "label": label,
         "label_final_verification": label_final_verification,
+        "label_unlinked": label_unlinked,
         "echo_template": raw.get("echo_template", ""),
         "options": raw.get("options", {}),
         "options_final_verification": raw.get("options_final_verification", {}),
@@ -2788,6 +2733,8 @@ def _build_task_type(state: WizardState) -> Prompt:
     recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
     rerun_suffix = t["options"].get("_RERUN_SUFFIX", "")
     next_suffix = t["options"].get("_NEXT_SUFFIX", "")
+    approve_suffix = t["options"].get("_APPROVE_SUFFIX", recommended_suffix)
+    blocked_rerun_suffix = t["options"].get("_BLOCKED_RERUN_SUFFIX", rerun_suffix)
     description_by_type = dict(TASK_TYPES)
     options: list[Option] = []
 
@@ -2813,10 +2760,21 @@ def _build_task_type(state: WizardState) -> Prompt:
     # `ready` 가 아니면 추천은 비고, 아래 `currentPhase` 재실행 옵션이 남는다.
     # 실패한 run 의 포인터가 `{"phase": "", "status": "blocked"}` 라는 점에서
     # 그것이 맞는 제안이다 — 그 옵션은 포인터가 아니라 `currentPhase` 에서 온다.
+    # 계획 승인 대기는 `awaitingApproval` 로 표시한다. 구현이 추천이지만 먼저
+    # 승인을 받아야 하므로 접미사로 구분한다. 열린 C-NNN 때문에 blocked 면
+    # 재실행은 답이 기록된 뒤에만 고르라고 접미사로 말한다.
     recommended = (revision_requested or state.task_type
                    or next_phase.autofill_task_type({"workflow": workflow}))
     if not recommended and not workflow:
         recommended = TASK_TYPE_VALUES[0]
+    pointer = next_phase.promote(workflow.get("nextRecommendedPhase"))
+    if workflow.get("awaitingApproval") is True and recommended == "implementation":
+        recommended_suffix = approve_suffix
+    if (
+        pointer["status"] == next_phase.STATUS_BLOCKED
+        and (workflow.get("currentPhase") or "") == "implementation-planning"
+    ):
+        rerun_suffix = blocked_rerun_suffix
     add(recommended, recommended_suffix)
     add(workflow.get("currentPhase") or "", rerun_suffix)
     add(_phase_after(recommended), next_suffix)
@@ -4191,14 +4149,15 @@ def _reverify_scope_preview(state: WizardState) -> Optional[dict]:
 
 
 def _reverify_scope_pick_required(state: WizardState) -> bool:
-    """좁힐 여지가 있는 재실행에서만 범위를 묻는다.
+    """좁힐 여지가 있거나, unlinked id 의 stage 번호를 받아야 할 때 묻는다.
 
-    링크가 끊겨 full 이 이미 확정된 재실행에서 물으면 어떤 답도 판정을 바꾸지
-    못한다 — 고를 수 없는 선택지를 내미는 화면이 하나 느는 것뿐이다. 그 경우
-    확인 블록의 `reverify-scope: full 예상` 줄이 이유까지 같이 알려준다.
+    unlinked 는 full 확정이 아니다. SHA 가 바뀌었거나 입력을 읽을 수 없어
+    `wouldForceFull` 인 경우만 질문이 의미 없다.
     """
     preview = _reverify_scope_preview(state)
-    return preview is not None and not preview["wouldForceFull"]
+    return preview is not None and (
+        not preview["wouldForceFull"] or bool(preview["unlinkedIds"])
+    )
 
 
 def _reverify_scope_step_pending(state: WizardState) -> bool:
@@ -4234,13 +4193,20 @@ def _prior_stage_numbers(state: WizardState) -> set[int]:
 def _build_reverify_scope_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "reverify_scope_pick")
     opts = t["options"]
+    preview = _reverify_scope_preview(state) or {}
+    unlinked = bool(preview.get("unlinkedIds"))
+    options = []
+    if not unlinked:
+        options.append(_opt("auto", opts["auto"]))
+        options.append(_opt("full", opts["full"]))
+        options.append(_opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]))
+    else:
+        options.append(_opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]))
+        options.append(_opt("full", opts["full"]))
+    label = t["label_unlinked"] if unlinked else t["label"]
     return Prompt(
-        step=S_REVERIFY_SCOPE_PICK, kind="pick", label=t["label"],
-        options=[
-            _opt("auto", opts["auto"]),
-            _opt("full", opts["full"]),
-            _opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]),
-        ],
+        step=S_REVERIFY_SCOPE_PICK, kind="pick", label=label,
+        options=options,
         echo_template=t["echo_template"])
 
 
@@ -4255,6 +4221,13 @@ def _submit_reverify_scope_pick(state: WizardState, value: str) -> Optional[str]
         raise WizardError(
             f"expected 'auto' / 'full' / {PICK_TYPE_CUSTOM!r}, got: {value!r}"
         )
+    if picked == "auto":
+        preview = _reverify_scope_preview(state) or {}
+        unlinked = preview.get("unlinkedIds") or []
+        if unlinked:
+            raise WizardError(
+                t["errors"]["unlinked_auto"].format(ids=", ".join(unlinked))
+            )
     state.reverify_scope = picked
     state.reverify_scope_pending_text = False
     return t["echo_suffixes"][picked]
@@ -4271,6 +4244,12 @@ def _submit_reverify_scope_stages(state: WizardState, value: str) -> Optional[st
     t = _p(state.workspace_root, "reverify_scope_stages")
     tokens = [token.strip() for token in value.split(",") if token.strip()]
     if not tokens:
+        preview = _reverify_scope_preview(state) or {}
+        unlinked = preview.get("unlinkedIds") or []
+        if unlinked:
+            raise WizardError(
+                t["errors"]["unlinked_empty"].format(ids=", ".join(unlinked))
+            )
         state.reverify_scope = "auto"
         state.reverify_scope_pending_text = False
         return t["echo_suffixes"]["auto"]
@@ -6341,13 +6320,13 @@ def _reverify_scope_line(state: WizardState) -> Optional[str]:
     if state.reverify_scope and state.reverify_scope != "auto":
         return _msg(state.workspace_root, "confirmation",
                     "reverify_scope_user_stages", stages=state.reverify_scope)
-    if not preview["wouldForceFull"]:
-        return _msg(state.workspace_root, "confirmation",
-                    "reverify_scope_incremental")
     if preview["unlinkedIds"]:
         return _msg(state.workspace_root, "confirmation",
                     "reverify_scope_unlinked",
                     ids=", ".join(preview["unlinkedIds"]))
+    if not preview["wouldForceFull"]:
+        return _msg(state.workspace_root, "confirmation",
+                    "reverify_scope_incremental")
     return _msg(state.workspace_root, "confirmation", "reverify_scope_full",
                 reason=preview["reason"])
 

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

@@ -9145,6 +9145,12 @@
       "properties": {
         "setAside": {"type": "array", "items": {"type": "object", "required": ["id", "reason"], "additionalProperties": false, "properties": {"id": {"type": "string", "minLength": 1}, "reason": {"type": "string", "enum": ["record", "observed", "deferred"]}}}},
         "stageLedger": {"type": "object", "additionalProperties": {"type": "string", "enum": ["done", "active", "ready", "blocked"]}},
+        "dispatchQueue": {
+          "type": "array",
+          "description": "Plan-item ids sent to verifiers this round. In-scope plus plan-wide; deferred and observed stages are omitted.",
+          "items": {"type": "string", "minLength": 1},
+          "uniqueItems": true
+        },
         "uniformVerifiers": {
           "type": "array",
           "description": "Verifiers whose every vote this round was one verdict. Advisory: a unanimous round is legitimate, but the gate reads as a three-way cross-check unless this sits beside it.",
@@ -9172,6 +9178,10 @@
             }
           }
         },
+        "gating": {
+          "type": "boolean",
+          "description": "If false, plan-body verification is advisory: majority-disagree does not block approval, the self-fix loop does not run, and only one automatic round is allowed. Legal only when designPreparation.mode is no-design-inputs and the Stage Map has exactly one row. Prepare emits true; plan-items prepare/seed flip it after those facts exist."
+        },
         "roundCount": {
           "type": "integer",
           "minimum": 0
@@ -9247,6 +9257,8 @@
             "properties": {
               "block": {"type": "string", "enum": ["execution", "record"]},
               "stageScope": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "integer", "minimum": 1}},
+              "contentHash": {"type": "string", "pattern": "^[a-f0-9]{64}$", "description": "SHA-256 of subject+payload+block+stageScope for the current extract."},
+              "verifiedContentHash": {"type": "string", "pattern": "^[a-f0-9]{64}$", "description": "contentHash at the last apply-verdicts. Matching hashes keep a pre-self-fix verdict."},
               "id": {
                 "type": "string",
                 "minLength": 1

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

@@ -9140,6 +9140,12 @@
       "properties": {
         "setAside": {"type": "array", "items": {"type": "object", "required": ["id", "reason"], "additionalProperties": false, "properties": {"id": {"type": "string", "minLength": 1}, "reason": {"type": "string", "enum": ["record", "observed", "deferred"]}}}},
         "stageLedger": {"type": "object", "additionalProperties": {"type": "string", "enum": ["done", "active", "ready", "blocked"]}},
+        "dispatchQueue": {
+          "type": "array",
+          "description": "Plan-item ids sent to verifiers this round. In-scope plus plan-wide; deferred and observed stages are omitted.",
+          "items": {"type": "string", "minLength": 1},
+          "uniqueItems": true
+        },
         "uniformVerifiers": {
           "type": "array",
           "description": "Verifiers whose every vote this round was one verdict. Advisory: a unanimous round is legitimate, but the gate reads as a three-way cross-check unless this sits beside it.",
@@ -9167,6 +9173,10 @@
             }
           }
         },
+        "gating": {
+          "type": "boolean",
+          "description": "If false, plan-body verification is advisory: majority-disagree does not block approval, the self-fix loop does not run, and only one automatic round is allowed. Legal only when designPreparation.mode is no-design-inputs and the Stage Map has exactly one row. Prepare emits true; plan-items prepare/seed flip it after those facts exist."
+        },
         "roundCount": {
           "type": "integer",
           "minimum": 0
@@ -9242,6 +9252,8 @@
             "properties": {
               "block": {"type": "string", "enum": ["execution", "record"]},
               "stageScope": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "integer", "minimum": 1}},
+              "contentHash": {"type": "string", "pattern": "^[a-f0-9]{64}$", "description": "SHA-256 of subject+payload+block+stageScope for the current extract."},
+              "verifiedContentHash": {"type": "string", "pattern": "^[a-f0-9]{64}$", "description": "contentHash at the last apply-verdicts. Matching hashes keep a pre-self-fix verdict."},
               "id": {
                 "type": "string",
                 "minLength": 1

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

@@ -0,0 +1,104 @@
+---
+name: okstra-chat
+description: Use when the user wants to create or join a global okstra chat room, send a message to everyone or to one participant, read unread arrivals, or reopen the inbox. Trigger words include "okstra chat", "okstra-chat", "chat room", "join the room", "send a chat message".
+---
+
+# okstra-chat
+
+Cross-session rooms in the global okstra home. Not a project task artifact.
+Do not write JSON. Call `okstra chat` and read its fixed text.
+
+Rooms are independent of tasks and runs. A participant is this host session.
+The display name is typed at join. Do not invent a default name.
+
+## When to use
+
+- The user wants a room that a Claude lead and a Grok lead can both join.
+- The user wants to send a message, see unread arrivals, or reopen the inbox.
+
+## Step 0: CLI
+
+Run as a separate Bash tool call with literal leading token:
+
+```bash
+okstra chat --help
+```
+
+If `okstra` is not on PATH, tell the user:
+
+`okstra not installed — run npx okstra@latest install once, then retry this skill.`
+
+Do not use `npx` from this skill.
+
+## Step 1: Create or join
+
+Ask one question: create a room, or join an existing room.
+
+If the host has a native picker, use it. Otherwise print a numbered list.
+
+### Create
+
+1. Ask for the room name as free input.
+2. Run `okstra chat create --room <room>`.
+3. Ask for the display name as free input. Do not suggest a generated name.
+4. Run `okstra chat join --room <room> --name <display>`.
+
+### Join
+
+1. Run `okstra chat rooms`.
+2. If the output is `no rooms`, say so and offer create.
+3. Otherwise pick a room from that list (picker, or numbered list if the picker limit is exceeded).
+4. Ask for the display name as free input.
+5. Run `okstra chat join --room <room> --name <display>`.
+
+`--name` is required. An empty name, `all`, or a name already in the room fails.
+
+## Step 2: Unread
+
+```bash
+okstra chat unread --room <room> --as <display>
+```
+
+Show the rows. Each row is `id:time:recipient:body`.
+
+## Step 3: Next action
+
+Ask: send, inbox, log, ack, or done.
+
+### Send
+
+1. Run `okstra chat members --room <room>`.
+2. Pick the recipient from `all` plus those names. Recipient is required.
+3. Ask for the body as free input.
+4. Run `okstra chat send --room <room> --as <display> --to <all|name> --body <text>`.
+
+### Inbox
+
+```bash
+okstra chat inbox --room <room> --as <display>
+```
+
+This is every arrival to `@you` or `all`, including messages already acked.
+
+### Log
+
+```bash
+okstra chat log --room <room> --as <display>
+```
+
+The whole room, including messages not addressed to you.
+
+### Ack
+
+After unread, mark the last id the user has read:
+
+```bash
+okstra chat ack --room <room> --as <display> --through <id>
+```
+
+## Rules
+
+- Call only `okstra chat`. Do not open files under the chat store.
+- Do not treat chat rows as evidence for a finding, verdict, or assignment.
+- Workers may run the same commands with `--name` and `--as`. Joining is optional.
+- Do not generate a display name from the provider, model, or execution label.

package/runtime/skills/okstra-inspect/facets/status.md

@@ -95,12 +95,13 @@ It has already promoted legacy values.
 The status response always includes one of:
 
 1. **Resume current run** — if `latestResumeCommandPath` exists, display that path.
-2. **Restart current phase** — task can be re-run with the same `task-key` and current `taskType`.
-Branches 3–5 are decided by `workflow.nextRecommendedPhase.status` alone — one status, one branch, no other field consulted:
+2. **Ask the user to approve** — if `workflow.awaitingApproval` is true. Tell the user to approve the plan (`okstra-run` with `--task-type implementation`, which asks `approve_plan_confirm`, or `--approve`). Quote `nextRecommendedPhase.rationale`. A `ready` pointer to `implementation` here means implementation is next after approval, not that it may launch as if already approved. Do not re-run `implementation-planning`.
+3. **Restart current phase** — only when `awaitingApproval` is false and the pointer is not `ready`. The task can be re-run with the same `task-key` and current `taskType`.
+Branches 4–6 are decided by `workflow.nextRecommendedPhase.status` when `awaitingApproval` is false — one status, one branch:
 
-3. **Start next phase** — `status` is `ready`. Propose `nextRecommendedPhase.phase` as the next run's `--task-type` and quote its `rationale` as the reason. This is the only status under which a named phase may be launched, so it is the only branch that proposes a run. A `ready` pointer to `release-handoff` already implies an `accepted` final-verification verdict (the report validator refuses that routing target otherwise), so do not re-gate it here.
-4. **Need more information** — `status` is `pending` (the last run did not settle where this task goes next) or `blocked` (it did settle, and the answer is that something outside the run has to change first). Neither proposes a run, and a leftover `phase` name does not change that — `prepare` keeps the name when it lowers a pointer to `pending`, so read `status`, not the emptiness of `phase`. Show the `rationale`, and for `blocked` state what it names as the obstacle. The way forward is a fresh brief, a clarification response, or a re-run of the current phase — not a next-phase launch.
-5. **Task complete (terminal)** — `status` is `terminal`: the task lifecycle ends here. This is **not** a "next phase" — do not propose a new okstra run. Surface the latest report and ask the user whether any follow-up task should be opened separately.
+4. **Start next phase** — `status` is `ready` and `awaitingApproval` is false. Propose `nextRecommendedPhase.phase` as the next run's `--task-type` and quote its `rationale` as the reason. This is the only status under which a named phase may be launched without a prior approval ask, so it is the only branch that proposes a run. A `ready` pointer to `release-handoff` already implies an `accepted` final-verification verdict (the report validator refuses that routing target otherwise), so do not re-gate it here.
+5. **Need more information** — `status` is `pending` (the last run did not settle where this task goes next) or `blocked` (it did settle, and the answer is that something outside the run has to change first). Neither proposes a run, and a leftover `phase` name does not change that — `prepare` keeps the name when it lowers a pointer to `pending`, so read `status`, not the emptiness of `phase`. Show the `rationale`, and for `blocked` state what it names as the obstacle. After `implementation-planning`, the first action is `okstra-user-response` on the named `C-NNN` ids; do not re-run planning until those answers exist, and do not start implementation.
+6. **Task complete (terminal)** — `status` is `terminal`: the task lifecycle ends here. This is **not** a "next phase" — do not propose a new okstra run. Surface the latest report and ask the user whether any follow-up task should be opened separately.
 
 ### status.4 — Update workStatus (write)