feat(plane): осмысленная статусная модель Plane (слой B — индикация)

Приводит статусы доски Plane к смыслу стадий конвейера, сохраняя
инвариант «статус — индикация, а не управление». Меняется только слой B
(отображение: src/plane_sync.py + точки выставления статуса в
stage_engine.py/webhooks/plane.py/reconciler.py); слой A — машина стадий
src/stages.py::STAGE_TRANSITIONS — остаётся байт-в-байт неизменным (AC-21).

- 6 новых логических ключей статуса (to_analyse, analysis, code_review,
  awaiting_deploy, deploying, monitoring) + сеттеры и диспетчер
  set_issue_stage_state.
- Project-relative alias-fallback (BR-12): новый ключ деградирует на
  базовый UUID того же проекта → нулевая регрессия для enduro-trails.
- Самодеплой (ORCH-036) индицирует фазы: Awaiting Deploy / Deploying;
  terminal-sync для self-hosting → Monitoring after Deploy, для прочих →
  терминальный Done.
- Post-deploy монитор (ORCH-021): HEALTHY → Done, DEGRADED → Blocked
  (только индикация; self-hosting ALERT_ONLY, прод не трогается, BR-5).
- Reconciler: триггер старта/резюма на To Analyse; Guard 2 учитывает
  новые активные ожидания без расширения skip-set на алиасах.
- never-raise контракт сеттеров и резолвера состояний сохранён.
- Раскатка — созданием статусов в Plane оператором, без kill-switch.

Инварианты не менялись: STAGE_TRANSITIONS, QG_CHECKS (12 чеков),
check_deploy_status, exit-код-контракт хука, merge-gate, схема БД.

ADR: docs/work-items/ORCH-066/06-adr/ADR-001-plane-status-model.md
Тесты: test_plane_status_model, test_plane_to_analyse_resume,
test_plane_status_failclosed + TC в существующих наборах. 774 passed.

Refs: ORCH-066

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/plane_sync.py

@@ -107,6 +107,19 @@ _DEFAULT_STATES = {
     # Feature 2 (verdict statuses) — Approved / Rejected.
     "approved":     "a519a341-dada-4a91-8910-7604f82b79c5",
     "rejected":     "ba958f3c-5db5-461d-8f82-89425e413b97",
+    # ORCH-066 (meaningful Plane status model, layer B): six new logical keys.
+    # Their _DEFAULT_STATES values alias the enduro-trails UUID of their BASE key
+    # (see _STATE_ALIAS_FALLBACK) so a project without these statuses created
+    # (enduro / Plane down / partial config) degrades to the current behaviour
+    # instead of producing an invalid PATCH state. The project-relative
+    # alias-fallback in get_project_states() overrides these with the *project's
+    # own* base UUID on the success path; these defaults are the last resort.
+    "to_analyse":      "b873d9eb-993c-48cd-97ac-99a9b1623967",  # = in_progress
+    "analysis":        "b873d9eb-993c-48cd-97ac-99a9b1623967",  # = in_progress
+    "code_review":     "ba0d802c-5218-41d4-ab43-978b0ea123ed",  # = review
+    "awaiting_deploy": "38fb1f64-aa1e-48a3-92e0-0b109679046b",  # = in_review
+    "deploying":       "b873d9eb-993c-48cd-97ac-99a9b1623967",  # = in_progress
+    "monitoring":      "381a2833-3c4e-4be5-bd0f-be84cb946ad8",  # = done
 }
 
 # Backward-compat alias — do NOT remove (tests + webhooks/plane.py import it).
@@ -128,6 +141,29 @@ _PLANE_NAME_TO_KEY: dict[str, str] = {
     "Needs Input":  "needs_input",
     "In Review":    "in_review",
     "Blocked":      "blocked",
+    # ORCH-066: meaningful per-stage / human-input statuses (layer B).
+    "To Analyse":               "to_analyse",
+    "Analysis":                 "analysis",
+    "Code-Review":              "code_review",
+    "Awaiting Deploy":          "awaiting_deploy",
+    "Deploying":                "deploying",
+    "Monitoring after Deploy":  "monitoring",
+}
+
+# ORCH-066 (BR-12): project-relative alias-fallback for the new logical keys.
+# After resolving states by name from the Plane API, any NEW key the project did
+# not define degrades to the UUID of its BASE key **from the same project** — so
+# the indication falls back to the current status and the PATCH stays valid even
+# for a partially-configured project. Enduro (none of the new statuses created)
+# collapses every new key onto its base, i.e. strictly the pre-ORCH-066
+# behaviour. Strengthened ORCH-059 AC-7 pattern.
+_STATE_ALIAS_FALLBACK: dict[str, str] = {
+    "to_analyse":      "in_progress",
+    "analysis":        "in_progress",
+    "code_review":     "review",
+    "awaiting_deploy": "in_review",
+    "deploying":       "in_progress",
+    "monitoring":      "done",
 }
 
 # Per-project state cache: {project_id: {logical_key: state_uuid}}
@@ -175,6 +211,16 @@ def get_project_states(project_id: str) -> dict[str, str]:
         if not resolved:
             raise ValueError("no recognisable states in API response")
 
+        # ORCH-066 (BR-12): project-relative alias-fallback. For each NEW key the
+        # project did not define, reuse the UUID of its BASE key FROM THIS SAME
+        # PROJECT (never a foreign/enduro UUID — that would yield an invalid PATCH
+        # state on a partially-configured orchestrator project). Runs BEFORE the
+        # _DEFAULT_STATES.setdefault below so a project's own base UUID wins over
+        # the static enduro default.
+        for new_key, base_key in _STATE_ALIAS_FALLBACK.items():
+            if new_key not in resolved and resolved.get(base_key):
+                resolved[new_key] = resolved[base_key]
+
         # Fill any missing keys from _DEFAULT_STATES so callers always get a
         # complete mapping (defensive against partial Plane configs).
         for k, v in _DEFAULT_STATES.items():
@@ -210,14 +256,16 @@ def reload_project_states(project_id: str = None) -> None:
 
 
 # Feature 3: map an orchestrator stage -> the Plane status to show on the board
-# when the pipeline ENTERS that stage. analysis stays driven by the existing
-# in_progress/in_review/needs_input logic (no dedicated status). deploy keeps
-# in_progress until done. Needs Input / In Review / Blocked remain higher
-# priority and are set explicitly elsewhere — do NOT override them from here.
+# when the pipeline ENTERS that stage. ORCH-066: analysis -> Analysis and
+# review -> Code-Review now have dedicated statuses. deploy keeps in_progress
+# until its own Phase A/B/C statuses drive it. Needs Input / In Review / Blocked
+# remain higher priority and are set explicitly elsewhere — do NOT override them
+# from here.
 STAGE_VISIBILITY_STATE = {
+    "analysis": "analysis",          # ORCH-066: analysis stage -> Analysis status
     "architecture": "architecture",
     "development": "development",
-    "review": "review",
+    "review": "code_review",         # ORCH-066: review stage -> Code-Review status
     "testing": "testing",
 }
 
@@ -225,22 +273,27 @@ STAGE_VISIBILITY_STATE = {
 # update_issue_state now calls stage_to_state() instead of looking up here.
 STAGE_TO_STATE = {
     "created":      _DEFAULT_STATES["todo"],
-    "analysis":     _DEFAULT_STATES["in_progress"],
+    # ORCH-066: analysis -> Analysis, review -> Code-Review. The new keys alias
+    # the same in_progress / review UUIDs in _DEFAULT_STATES, so legacy callers /
+    # tests that compare against concrete UUIDs see byte-identical values.
+    "analysis":     _DEFAULT_STATES["analysis"],
     "architecture": _DEFAULT_STATES["architecture"],
     "development":  _DEFAULT_STATES["development"],
-    "review":       _DEFAULT_STATES["review"],
+    "review":       _DEFAULT_STATES["code_review"],
     "testing":      _DEFAULT_STATES["testing"],
     "deploy":       _DEFAULT_STATES["in_progress"],
     "done":         _DEFAULT_STATES["done"],
 }
 
 # Map orchestrator stage -> logical state key (project-independent).
+# ORCH-066: analysis -> analysis, review -> code_review (was in_progress/review).
+# deploy stays in_progress (Phase A/B/C drive it directly, not update_issue_state).
 _STAGE_TO_STATE_KEY = {
     "created":      "todo",
-    "analysis":     "in_progress",
+    "analysis":     "analysis",
     "architecture": "architecture",
     "development":  "development",
-    "review":       "review",
+    "review":       "code_review",
     "testing":      "testing",
     "deploy":       "in_progress",
     "done":         "done",
@@ -575,6 +628,58 @@ def set_issue_in_progress(work_item_id: str, project_id: str = None):
     _set_issue_state_direct(work_item_id, state_id, project_id)
 
 
+def set_issue_analysis(work_item_id: str, project_id: str = None):
+    """ORCH-066: set issue to 'Analysis' — analyst is working (start / resume).
+
+    Degrades to the project's In Progress UUID when the 'Analysis' status is not
+    created (alias-fallback). never-raise (via _set_issue_state_direct).
+    """
+    project_id = _resolve_project_id(work_item_id, project_id)
+    state_id = get_project_states(project_id)["analysis"]
+    _set_issue_state_direct(work_item_id, state_id, project_id)
+
+
+def set_issue_code_review(work_item_id: str, project_id: str = None):
+    """ORCH-066: set issue to 'Code-Review' — review stage indication.
+
+    Degrades to the project's Review UUID when 'Code-Review' is not created.
+    """
+    project_id = _resolve_project_id(work_item_id, project_id)
+    state_id = get_project_states(project_id)["code_review"]
+    _set_issue_state_direct(work_item_id, state_id, project_id)
+
+
+def set_issue_awaiting_deploy(work_item_id: str, project_id: str = None):
+    """ORCH-066: set issue to 'Awaiting Deploy' — self-deploy Phase A approval-pending.
+
+    Degrades to the project's In Review UUID when 'Awaiting Deploy' is not created.
+    """
+    project_id = _resolve_project_id(work_item_id, project_id)
+    state_id = get_project_states(project_id)["awaiting_deploy"]
+    _set_issue_state_direct(work_item_id, state_id, project_id)
+
+
+def set_issue_deploying(work_item_id: str, project_id: str = None):
+    """ORCH-066: set issue to 'Deploying' — self-deploy Phase B prod deploy in flight.
+
+    Degrades to the project's In Progress UUID when 'Deploying' is not created.
+    """
+    project_id = _resolve_project_id(work_item_id, project_id)
+    state_id = get_project_states(project_id)["deploying"]
+    _set_issue_state_direct(work_item_id, state_id, project_id)
+
+
+def set_issue_monitoring(work_item_id: str, project_id: str = None):
+    """ORCH-066: set issue to 'Monitoring after Deploy' — post-deploy window open.
+
+    Degrades to the project's Done UUID when 'Monitoring after Deploy' is not
+    created (so the board shows Done, exactly as before ORCH-066).
+    """
+    project_id = _resolve_project_id(work_item_id, project_id)
+    state_id = get_project_states(project_id)["monitoring"]
+    _set_issue_state_direct(work_item_id, state_id, project_id)
+
+
 def set_issue_stage_state(work_item_id: str, stage: str, project_id: str = None):
     """Feature 3: move the issue to the board status for a pipeline stage.
 

src/reconciler.py

@@ -193,12 +193,22 @@ class Reconciler:
             self._note_unblock(task.get("work_item_id") or str(task_id), stage)
 
     def _is_blocked_or_needs_input(self, task: dict) -> bool:
-        """ORCH-060 Guard 2: is this issue in an explicit human Plane gate?
+        """Guard 2 (ORCH-060 + ORCH-066): is this issue waiting for a human OR in
+        an active orchestrator wait that F-1 must not "revive"?
 
         Variant A (no schema migration): resolve the task's Plane project, fetch
-        the issue's current state uuid and compare against the project's
-        ``blocked`` / ``needs_input`` states. ``tasks`` has no status column, so
-        the live Plane state is the source of truth.
+        the issue's current state uuid and compare against a skip-set. ``tasks``
+        has no status column, so the live Plane state is the source of truth.
+
+        Skip-set = explicit human gates (``blocked`` / ``needs_input``) PLUS the
+        ORCH-066 active waits (``awaiting_deploy`` / ``deploying`` / ``monitoring``,
+        BR-13). **Anti-regress (CRITICAL):** the active-wait keys alias onto
+        ``in_review`` / ``in_progress`` / ``done`` on a project that did not create
+        them. Adding them verbatim would make F-1 wrongly skip enduro
+        In Progress / Done tasks (regression of ORCH-053/060). So they are
+        included ONLY when DISTINCT from the project's base working statuses
+        (i.e. actually created as separate statuses): enduro collapses them to {}
+        -> zero regress; orchestrator keeps three real statuses -> BR-13.
 
         **Never-raise, conservative fallback.** Any error / unresolved project /
         missing state -> return ``True`` (treat as "possibly blocked" -> skip):
@@ -219,7 +229,22 @@ class Reconciler:
             cur = fetch_issue_state(issue_id, pid)
             if cur is None:
                 return True  # Plane unreachable / no state -> conservative skip
-            return cur in {states.get("blocked"), states.get("needs_input")}
+            # ORCH-066 BR-13: active orchestrator waits, minus base working
+            # statuses so aliased (enduro) keys never widen the skip-set.
+            base_working = {
+                states.get(k) for k in (
+                    "backlog", "todo", "in_progress", "in_review", "review",
+                    "architecture", "development", "testing",
+                    "approved", "rejected", "done",
+                )
+            }
+            extra_waits = {
+                states.get("awaiting_deploy"),
+                states.get("deploying"),
+                states.get("monitoring"),
+            } - base_working - {None}
+            skip_set = {states.get("blocked"), states.get("needs_input")} | extra_waits
+            return cur in skip_set
         except Exception as e:  # noqa: BLE001 - never break the tick
             logger.warning(
                 f"reconciler Guard 2: blocked-check failed for task "
@@ -241,15 +266,19 @@ class Reconciler:
     def _reconcile_plane_project(self, proj) -> None:
         pid = proj.plane_project_id
         # Resolve the actionable state uuids per-project (never hardcode).
+        # ORCH-066 (AC-19): the start/resume trigger is `To Analyse` (was
+        # In Progress). On a project without that status, `to_analyse` aliases to
+        # the project's own `in_progress` UUID, so enduro behaviour is identical
+        # (and `list_issues_by_state` deduplicates the uuid via its internal set).
         states = get_project_states(pid)
-        in_progress = states["in_progress"]
+        to_analyse = states["to_analyse"]
         approved = states["approved"]
         rejected = states["rejected"]
-        issues = list_issues_by_state(pid, [in_progress, approved, rejected])
+        issues = list_issues_by_state(pid, [to_analyse, approved, rejected])
         for issue in issues:
             try:
                 self._reconcile_plane_issue(
-                    issue, pid, in_progress, approved, rejected
+                    issue, pid, to_analyse, approved, rejected
                 )
             except Exception as e:  # noqa: BLE001 - isolate one issue's failure
                 logger.error(
@@ -258,7 +287,7 @@ class Reconciler:
 
     def _reconcile_plane_issue(
         self, issue: dict, project_id: str,
-        in_progress: str, approved: str, rejected: str,
+        to_analyse: str, approved: str, rejected: str,
     ) -> None:
         issue_id = str(issue.get("id") or "")
         if not issue_id:
@@ -288,10 +317,16 @@ class Reconciler:
             "description_stripped": issue.get("description_stripped", ""),
         }
 
-        if new_state == in_progress and task is None:
-            # In Progress without a task -> start the pipeline (lost start webhook).
+        if new_state == to_analyse and task is None:
+            # To Analyse without a task -> start the pipeline (lost start webhook).
             self._dispatch(handle_status_start, issue_data, project_id)
             self._note_unblock(issue_id, "analysis")
+        elif new_state == to_analyse and task is not None:
+            # To Analyse with an existing (idle) task -> resume the analyst from
+            # Needs Input (lost resume webhook). handle_status_start applies its
+            # own busy-guard / start-vs-resume fork.
+            self._dispatch(handle_status_start, issue_data, project_id)
+            self._note_unblock(task.get("work_item_id") or issue_id, task["stage"])
         elif new_state == approved and task is not None:
             # Approved but the stage never advanced -> replay the verdict.
             self._dispatch(handle_verdict, issue_data, project_id, approved=True)

src/stage_engine.py

@@ -53,6 +53,10 @@ from .plane_sync import (
     set_issue_in_progress,
     set_issue_blocked,
     set_issue_done,
+    set_issue_analysis,
+    set_issue_awaiting_deploy,
+    set_issue_deploying,
+    set_issue_monitoring,
 )
 from .config import settings
 
@@ -335,14 +339,28 @@ def advance_stage(
         # here, so explicitly drive the Plane issue into the terminal Done state
         # (PLANE_STATES['done'] — mapping unchanged) in addition to the
         # stage-change comment above.
+        # ORCH-066 (AC-8/AC-9): split terminal-sync by whether post-deploy
+        # monitoring applies. For self-hosting (post_deploy_applies==True) the
+        # task enters a `Monitoring after Deploy` window, NOT terminal Done yet —
+        # the monitor finalises Done/Blocked (run_post_deploy_monitor). For
+        # non-self repos the behaviour is unchanged: terminal Done immediately.
+        # Where the `Monitoring after Deploy` status is absent, set_issue_monitoring
+        # degrades to the project's Done UUID -> identical to today.
         if next_stage == "done" and work_item_id:
             try:
-                set_issue_done(work_item_id)
-                logger.info(
-                    f"Task {task_id}: deploy->done, Plane state forced to Done"
-                )
+                if post_deploy.post_deploy_applies(repo):
+                    set_issue_monitoring(work_item_id)
+                    logger.info(
+                        f"Task {task_id}: deploy->done (self), Plane state -> "
+                        f"Monitoring after Deploy (post-deploy window)"
+                    )
+                else:
+                    set_issue_done(work_item_id)
+                    logger.info(
+                        f"Task {task_id}: deploy->done, Plane state forced to Done"
+                    )
             except Exception as e:
-                logger.error(f"Task {task_id}: failed to set Plane Done: {e}")
+                logger.error(f"Task {task_id}: failed to set Plane terminal state: {e}")
 
         # ORCH-043: the merge has landed (deploy->done). Release the merge lease as
         # a backstop in case the PR-merged webhook was lost (holder-aware no-op if a
@@ -666,7 +684,9 @@ def _handle_qg_failure_rollbacks(
             notify_stage_change(task_id, current_stage, "analysis")
             plane_notify_stage(work_item_id, current_stage, "analysis")
             result.rolled_back_to = "analysis"
-            set_issue_in_progress(work_item_id)
+            # ORCH-066 (AC-3): rolled back to analysis -> indicate `Analysis`
+            # (degrades to In Progress where the status is not created).
+            set_issue_analysis(work_item_id)
             with open(conflict_path, "r") as cf:
                 conflict_text = cf.read()[:500]
             plane_add_comment(
@@ -1009,7 +1029,11 @@ def _handle_self_deploy_phase_a(
     result.note = "self-deploy-approval-pending"
 
     if work_item_id:
-        set_issue_in_review(work_item_id)
+        # ORCH-066 (AC-6/AC-13): Phase A approval-pending is now `Awaiting Deploy`,
+        # which discharges `In Review` of the deploy-approval meaning (In Review
+        # stays for analyst BRD/review approve-pending only). Degrades to In Review
+        # where the status is not created.
+        set_issue_awaiting_deploy(work_item_id)
     # ORCH-036: belt-and-suspenders — wipe any STALE deploy-state markers before
     # arming a fresh approve. A prior FAILED pass clears on rollback, but clearing
     # here too guarantees the entry to every new prod-deploy pass starts clean
@@ -1069,6 +1093,10 @@ def _handle_self_deploy_phase_b(task_id, repo, work_item_id, branch, result: Adv
     self_deploy.write_marker(
         repo, work_item_id, self_deploy.INITIATED, content=str(time.time())
     )
+    # ORCH-066 (AC-7): the prod deploy is now in flight -> indicate `Deploying`
+    # (degrades to In Progress where the status is not created).
+    if work_item_id:
+        set_issue_deploying(work_item_id)
     task_desc = (
         f"Work item: {work_item_id}\nRepo: {repo}\nBranch: {branch}\n"
         f"Stage: deploy\nNote: deploy-finalize poll (prod self-deploy initiated)."
@@ -1263,6 +1291,12 @@ def run_post_deploy_monitor(job: dict):
             settings.post_deploy_window_s, checks_total, checks_failed,
         )
         post_deploy.mark_done(repo, work_item_id)
+        # ORCH-066 (AC-10): the post-deploy window closed clean -> terminal Done.
+        if work_item_id:
+            try:
+                set_issue_done(work_item_id)
+            except Exception as e:  # noqa: BLE001 - never break the tick
+                logger.warning(f"post-deploy: set Done failed for {work_item_id}: {e}")
         _notify_post_deploy(
             work_item_id,
             f"✅ {work_item_id}: пост-деплой окно завершено чисто "
@@ -1303,6 +1337,15 @@ def run_post_deploy_monitor(job: dict):
             f"self-hosting запрещён (BR-5).",
         )
 
+    # ORCH-066 (AC-11/AC-12): a confirmed degradation -> indicate `Blocked` for
+    # manual intervention. This is INDICATION ONLY — the tick NEVER restarts /
+    # rolls back the prod container (self-hosting stays ALERT_ONLY, BR-5).
+    if work_item_id:
+        try:
+            set_issue_blocked(work_item_id)
+        except Exception as e:  # noqa: BLE001 - never break the tick
+            logger.warning(f"post-deploy: set Blocked failed for {work_item_id}: {e}")
+
     post_deploy.write_post_deploy_log(
         repo, work_item_id, branch, post_deploy.DEGRADED, action_taken,
         settings.post_deploy_window_s, checks_total, checks_failed,

src/webhooks/plane.py

@@ -147,10 +147,15 @@ async def handle_issue_updated(data: dict, project_id: str = ""):
         return
 
     # ORCH-10: resolve expected state UUIDs per the incoming issue's project so
-    # both enduro (b873d9eb) and orchestrator (e331bfb3) In Progress trigger the
+    # both enduro (b873d9eb) and orchestrator (e331bfb3) statuses trigger the
     # pipeline. Using PLANE_STATES["in_progress"] here was the root-cause blocker.
+    # ORCH-066: the start/resume trigger is now `To Analyse` (human entry-point),
+    # which discharges `In Progress` of its overloaded "start the pipeline"
+    # meaning. Fail-closed: on a project without the `To Analyse` status,
+    # `to_analyse` aliases to the project's own `in_progress` UUID, so moving an
+    # enduro issue to In Progress still triggers start/resume (AC-17).
     proj_states = get_project_states(project_id)
-    if new_state == proj_states["in_progress"]:
+    if new_state == proj_states["to_analyse"]:
         await handle_status_start(data, project_id)
     elif new_state == proj_states["approved"]:
         await handle_verdict(data, project_id, approved=True)
@@ -235,9 +240,14 @@ async def handle_status_start(data: dict, project_id: str = ""):
     )
     job_id = enqueue_job(stage_agent, repo, task_desc, task_id=task_id)
     logger.info(
-        f"Task {task_id}: returned to In Progress (Needs Input answered), "
+        f"Task {task_id}: returned to To Analyse (Needs Input answered), "
         f"relaunched {stage_agent} for stage {current_stage} (job_id={job_id})"
     )
+    # ORCH-066 (AC-3): a resume of the analyst (the only Needs-Input owner) is
+    # re-indicated as `Analysis`; other stages keep their own indication.
+    if current_stage == "analysis":
+        from ..plane_sync import set_issue_analysis as _set_analysis
+        _set_analysis(work_item_id)
     try:
         _add_comment(
             work_item_id,
@@ -538,6 +548,10 @@ async def start_pipeline(data: dict, project_id: str = ""):
         )
         job_id = enqueue_job("analyst", repo, task_desc, task_id=task_id)
         logger.info(f"Task {task_id}: enqueued analyst (job_id={job_id})")
+        # ORCH-066 (AC-3): indicate the analysis stage with the dedicated
+        # `Analysis` status (degrades to In Progress where it is not created).
+        from ..plane_sync import set_issue_analysis as _set_analysis
+        _set_analysis(work_item_id, plane_project_id)
         # Post start comment to Plane
         from ..plane_sync import add_comment as _add_comment
         _add_comment(work_item_id, "\U0001f50d Analyst \u0437\u0430\u043f\u0443\u0449\u0435\u043d. BRD/\u0422\u0417/AC/TestPlan \u0432 \u0440\u0430\u0431\u043e\u0442\u0435 (\u043e\u0436\u0438\u0434\u0430\u0439\u0442\u0435 8-15 \u043c\u0438\u043d).", author="analyst")
@@ -579,9 +593,11 @@ async def _rollback_stage(
         (via the existing rollback notify + an enqueue of the prev-stage agent).
     """
     if current_stage == "analysis":
-        # Already in analysis — just relaunch analyst with rejection reason
-        from ..plane_sync import set_issue_in_progress
-        set_issue_in_progress(work_item_id)
+        # Already in analysis — just relaunch analyst with rejection reason.
+        # ORCH-066 (AC-3): indicate `Analysis` (degrades to In Progress where the
+        # status is not created).
+        from ..plane_sync import set_issue_analysis
+        set_issue_analysis(work_item_id)
         task_desc = (
             f"Work item: {work_item_id}\nRepo: {repo}\nBranch: {branch}\n"
             f"Stage: analysis\nNote: Stakeholder REJECTED your artifacts. "