okstra 0.110.0 → 0.112.0

package/runtime/python/okstra_ctl/render.py

@@ -1010,6 +1010,10 @@ def render_task_manifest(manifest_path: str, ctx: dict) -> None:
         "leadRuntime": _lead_runtime(ctx),
         "leadAdapter": _lead_adapter(ctx),
         "workCategory": work_category,
+        # user-managed status (set-work-status CLI) — carried across re-renders
+        "workStatus": existing.get("workStatus", ""),
+        "workStatusUpdatedAt": existing.get("workStatusUpdatedAt", ""),
+        "workStatusNote": existing.get("workStatusNote", ""),
         "taskBriefPath": ctx.get("BRIEF_RELATIVE_PATH", ""),
         "recommendedWorkers": reviewers,
         "relatedTasks": related_tasks,
@@ -1740,6 +1744,9 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
     convergence_path = ctx.get("OKSTRA_CONVERGENCE_PATH") or str(
         home_prompts / "lead" / "convergence.md"
     )
+    plan_body_verification_path = ctx.get("OKSTRA_PLAN_BODY_VERIFICATION_PATH") or str(
+        home_prompts / "lead" / "plan-body-verification.md"
+    )
     report_writer_path = ctx.get("OKSTRA_REPORT_WRITER_PATH") or str(
         home_prompts / "lead" / "report-writer.md"
     )
@@ -1753,6 +1760,7 @@ def inject_lead_prompt_computed_tokens(ctx: dict) -> None:
         f"- Context loader: `{context_loader_path}`\n"
         f"- Team contract: `{team_contract_path}`\n"
         f"- Convergence contract: `{convergence_path}`\n"
+        f"- Plan-body verification contract (implementation-planning Phase 6 sub-step only): `{plan_body_verification_path}`\n"
         f"- Report writer contract: `{report_writer_path}`\n"
         f"- Coding preflight pack: `{coding_preflight_dir}`"
     )

package/runtime/python/okstra_ctl/report_views.py

@@ -2,11 +2,17 @@
 
 Single product, single source of truth:
 
-* ``render_html(src_md, *, run_meta)`` — deterministic self-contained
-  HTML renderer for human readers. Sections §1/§3/§4 user-actionable
-  rows (those reachable from §1 ``C-*`` IDs) get embedded ``<form>``
-  controls. §5.6 / §5.7 / §5.8 deliverable sub-sections are explicitly
-  excluded from form attachment — they are read-only deliverables.
+* ``build_report_view_model(src_md, *, run_meta)`` — deterministic
+  server-side Report View Model for human readers. It carries source digest,
+  rendered body HTML, response IDs, sidecar hints, and optional approval
+  context.
+* ``render_report_view_model(model, *, css, js)`` — self-contained HTML
+  renderer over that model. Sections §1/§3/§4 user-actionable rows (those
+  reachable from §1 ``C-*`` IDs) get embedded ``<form>`` controls. §5.6 /
+  §5.7 / §5.8 deliverable sub-sections are explicitly excluded from form
+  attachment — they are read-only deliverables.
+* ``render_html(src_md, *, run_meta)`` remains a compatibility wrapper around
+  the model builder + renderer.
 
 User responses are NEVER merged back into the original report. The HTML
 serialises a ``user-response`` markdown sidecar via ``Export user
@@ -101,34 +107,56 @@ class RunMeta:
     source_report: str  # relative path of the .md the HTML is derived from
 
 
-def render_html(
+@dataclass(frozen=True)
+class ReportViewModel:
+    run_meta: RunMeta
+    title: str
+    body_html: str
+    source_digest: str
+    response_ids: tuple[str, ...]
+    sidecar_name: str
+    sidecar_dir: str
+    approval_ctx: PlanApprovalContext | None = None
+
+
+def build_report_view_model(
     src_md: str,
     *,
     run_meta: RunMeta,
-    css: str,
-    js: str,
     approval_ctx: PlanApprovalContext | None = None,
-) -> str:
-    """Return a single self-contained HTML document for ``src_md``.
-
-    ``css`` / ``js`` are inlined verbatim. No external URLs are written
-    into the document (validator enforces this — see
-    validate-report-views.py).
-    """
-    # Compute the digest over the source MD body. The validator
-    # recomputes the same digest from the current MD and compares it to
-    # the value embedded in run-meta below.
+) -> ReportViewModel:
     digest = source_digest(src_md)
     body_md = _strip_leading_frontmatter(src_md)
     body_html, toc_headings = _markdown_to_html(body_md)
     body_html = _inject_toc(body_html, toc_headings)
-    response_ids = sorted({item.row_id for item in (parse_clarification_items(body_md) or [])})
+    response_ids = tuple(
+        sorted({item.row_id for item in (parse_clarification_items(body_md) or [])})
+    )
+    return ReportViewModel(
+        run_meta=run_meta,
+        title=f"{run_meta.task_key} — {run_meta.task_type} #{run_meta.seq}",
+        body_html=body_html,
+        source_digest=digest,
+        response_ids=response_ids,
+        sidecar_name=f"user-response-{run_meta.task_type}-{run_meta.seq}.md",
+        sidecar_dir=f"runs/{run_meta.task_type}/user-responses/",
+        approval_ctx=approval_ctx,
+    )
 
-    title = html.escape(f"{run_meta.task_key} — {run_meta.task_type} #{run_meta.seq}")
-    response_ids_json = "[" + ",".join('"' + html.escape(rid) + '"' for rid in response_ids) + "]"
-    sidecar_name = html.escape(f"user-response-{run_meta.task_type}-{run_meta.seq}.md")
-    sidecar_dir = html.escape(f"runs/{run_meta.task_type}/user-responses/")
 
+def render_report_view_model(
+    model: ReportViewModel,
+    *,
+    css: str,
+    js: str,
+) -> str:
+    title = html.escape(model.title)
+    response_ids_json = "[" + ",".join(
+        '"' + html.escape(rid) + '"' for rid in model.response_ids
+    ) + "]"
+    sidecar_name = html.escape(model.sidecar_name)
+    sidecar_dir = html.escape(model.sidecar_dir)
+    run_meta = model.run_meta
     return (
         f"<!DOCTYPE html>\n"
         f"<html lang=\"ko\">\n"
@@ -143,8 +171,8 @@ def render_html(
         f"  <div>{title}</div>\n"
         f"  <button type=\"button\" data-action=\"export-user-response\">Export user response</button>\n"
         f"</header>\n"
-        f"<main>{body_html}</main>\n"
-        f"{_plan_approval_section(approval_ctx, run_meta) if approval_ctx else ''}"
+        f"<main>{model.body_html}</main>\n"
+        f"{_plan_approval_section(model.approval_ctx, run_meta) if model.approval_ctx else ''}"
         f"<footer class=\"report-footer\">\n"
         f"  <button type=\"button\" data-action=\"export-user-response\">Export user response</button>\n"
         f"  <p class=\"user-response-hint\">Export 클릭 시 <code>{sidecar_name}</code> 가 다운로드됩니다 — "
@@ -158,7 +186,7 @@ def render_html(
         f"\"task-type\":\"{html.escape(run_meta.task_type)}\","
         f"\"seq\":\"{html.escape(run_meta.seq)}\","
         f"\"source-report\":\"{html.escape(run_meta.source_report)}\","
-        f"\"source-sha256\":\"{digest}\","
+        f"\"source-sha256\":\"{model.source_digest}\","
         f"\"response-ids\":{response_ids_json}}}"
         f"</script>\n"
         f"<script>{js}</script>\n"
@@ -167,6 +195,28 @@ def render_html(
     )
 
 
+def render_html(
+    src_md: str,
+    *,
+    run_meta: RunMeta,
+    css: str,
+    js: str,
+    approval_ctx: PlanApprovalContext | None = None,
+) -> str:
+    """Return a single self-contained HTML document for ``src_md``.
+
+    ``css`` / ``js`` are inlined verbatim. No external URLs are written
+    into the document (validator enforces this — see
+    validate-report-views.py).
+    """
+    model = build_report_view_model(
+        src_md,
+        run_meta=run_meta,
+        approval_ctx=approval_ctx,
+    )
+    return render_report_view_model(model, css=css, js=js)
+
+
 def _markdown_to_html(
     src_md: str,
 ) -> tuple[str, list[tuple[int, str, str]]]:

package/runtime/python/okstra_ctl/set_work_status.py

@@ -0,0 +1,147 @@
+"""task-manifest.json 의 workStatus 를 갱신하는 단일 CLI 진입점.
+
+okstra-inspect status.4 가 Edit 도구로 하던 수동 JSON 편집(키 순서·개행 보존
+규칙을 프롬프트로 강제)을 CLI 로 수렴시킨다. 직렬화는 render._write_json 과
+동일한 json.dumps(indent=2, ensure_ascii=False) + "\n" 이므로 재렌더와 byte
+규칙이 일치한다. discovery/task-catalog.json 은 여기서 재생성하지 않는다 —
+다음 run 렌더가 manifest 를 재투영할 때까지 stale 할 수 있다.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from okstra_ctl.ids import slugify_task_segment
+from okstra_project import (
+    ResolverError,
+    StateError,
+    resolve_project_root,
+    resolve_task_reference,
+)
+
+ALLOWED_WORK_STATUSES = ("todo", "in-progress", "blocked", "done")
+
+
+def _emit(payload: dict) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def _manifest_path(project_root: Path, entry: dict) -> Path:
+    rel = entry.get("taskManifestPath") or ""
+    if rel:
+        candidate = Path(rel)
+        return candidate if candidate.is_absolute() else project_root / candidate
+    group_seg = entry.get("taskGroupPathSegment") or slugify_task_segment(
+        entry.get("taskGroup", "")
+    )
+    id_seg = entry.get("taskIdPathSegment") or slugify_task_segment(
+        entry.get("taskId", "")
+    )
+    return project_root / ".okstra" / "tasks" / group_seg / id_seg / "task-manifest.json"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Set a task's user-managed workStatus in task-manifest.json."
+    )
+    parser.add_argument(
+        "token",
+        help="full task-key (<project-id>:<task-group>:<task-id>) or bare task-id",
+    )
+    parser.add_argument("status", choices=ALLOWED_WORK_STATUSES)
+    parser.add_argument(
+        "--note",
+        default=None,
+        help="set workStatusNote; omit to leave any existing note untouched",
+    )
+    parser.add_argument(
+        "--task-group", default="", help="scope a bare task-id match to this task-group"
+    )
+    parser.add_argument("--project-root", default="", help="project root for catalog lookup")
+    parser.add_argument("--cwd", default=".", help="cwd for project root resolution")
+    parser.add_argument("--json", action="store_true", help="emit JSON (always on)")
+    args = parser.parse_args(argv)
+
+    try:
+        project_root = resolve_project_root(explicit_root=args.project_root, cwd=args.cwd)
+    except ResolverError as exc:
+        _emit({"ok": False, "stage": "resolve", "reason": str(exc)})
+        return 2
+
+    token = args.token
+    task_group = args.task_group
+    if token.count(":") == 2:
+        _, key_group, key_id = token.split(":")
+        token = key_id
+        task_group = key_group or task_group
+
+    try:
+        matches = resolve_task_reference(
+            project_root, token, task_group=task_group or None
+        )
+    except StateError as exc:
+        _emit({"ok": False, "stage": "catalog", "reason": str(exc)})
+        return 2
+
+    if not matches:
+        _emit({"ok": False, "stage": "not-found", "token": args.token})
+        return 1
+    if len(matches) > 1:
+        _emit({"ok": False, "stage": "ambiguous", "matches": matches})
+        return 2
+
+    entry = matches[0]
+    manifest_path = _manifest_path(project_root, entry)
+    if not manifest_path.exists():
+        _emit(
+            {
+                "ok": False,
+                "stage": "manifest-missing",
+                "taskKey": entry.get("taskKey", ""),
+                "taskManifestPath": str(manifest_path),
+            }
+        )
+        return 1
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except ValueError as exc:
+        _emit(
+            {
+                "ok": False,
+                "stage": "manifest-invalid",
+                "taskManifestPath": str(manifest_path),
+                "reason": str(exc),
+            }
+        )
+        return 1
+
+    previous = manifest.get("workStatus", "")
+    manifest["workStatus"] = args.status
+    manifest["workStatusUpdatedAt"] = datetime.now(timezone.utc).strftime(
+        "%Y-%m-%dT%H:%M:%SZ"
+    )
+    if args.note is not None:
+        manifest["workStatusNote"] = args.note
+    manifest_path.write_text(
+        json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+
+    _emit(
+        {
+            "ok": True,
+            "taskKey": entry.get("taskKey", ""),
+            "previousWorkStatus": previous,
+            "workStatus": args.status,
+            "workStatusUpdatedAt": manifest["workStatusUpdatedAt"],
+            "workStatusNote": manifest.get("workStatusNote", ""),
+            "taskManifestPath": str(manifest_path),
+        }
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/stage_targets.py

@@ -38,6 +38,158 @@ class FinalVerificationTarget:
     reports: list[str]
 
 
+@dataclass(frozen=True)
+class StageLifecycle:
+    stage: int
+    depends_on: list[int]
+    done: bool
+    started: bool
+    reserved: bool
+    verified_accepted: bool
+    pr_covered: bool
+    head_commit: str
+    report_path: str
+
+    def handoff_eligibility_record(self) -> dict[str, Any]:
+        reasons: list[str] = []
+        if self.pr_covered:
+            reasons.append("already-in-pr")
+        else:
+            if not self.done:
+                reasons.append("not-done")
+            if not self.verified_accepted:
+                reasons.append("not-verified-accepted")
+        return {
+            "stage": self.stage,
+            "depends_on": list(self.depends_on),
+            "eligible": not reasons,
+            "reasons": reasons,
+            "head_commit": self.head_commit,
+        }
+
+
+@dataclass(frozen=True)
+class StageLifecycleSnapshot:
+    stage_map: list[dict[str, Any]]
+    rows: list[dict[str, Any]]
+    done_rows: list[dict[str, Any]]
+    done_by_stage: dict[int, dict[str, Any]]
+    done_stages: set[int]
+    started_stages: set[int]
+    reserved_stages: set[int]
+    verified_accepted_stages: set[int]
+    pr_covered_stages: set[int]
+    lifecycles: list[StageLifecycle]
+
+    def lifecycle_for(self, stage_number: int) -> StageLifecycle:
+        for lifecycle in self.lifecycles:
+            if lifecycle.stage == stage_number:
+                return lifecycle
+        raise StageTargetError(f"stage {stage_number} not in Stage Map")
+
+    def resolve_effective_stages(
+        self,
+        requested: str,
+        budget: int = RUN_STEP_BUDGET,
+    ) -> list[int]:
+        return resolve_effective_stages(
+            self.stage_map,
+            self.done_stages,
+            requested,
+            budget=budget,
+            started_stages=self.started_stages,
+            reserved_stages=self.reserved_stages,
+        )
+
+    def resolve_implementation_stage(self, requested: str) -> int:
+        return self.resolve_effective_stages(requested)[0]
+
+    def concurrent_stage_numbers(self, *, selected_stage: int) -> list[int]:
+        return sorted(self.reserved_stages - self.done_stages - {selected_stage})
+
+    def handoff_eligibility(self) -> list[dict[str, Any]]:
+        return [
+            lifecycle.handoff_eligibility_record()
+            for lifecycle in self.lifecycles
+        ]
+
+
+def _stage_consumer_state_from_rows(rows: list[dict[str, Any]]) -> Any:
+    from .consumers import stage_consumer_state_from_rows
+
+    return stage_consumer_state_from_rows(rows)
+
+
+def stage_lifecycle_snapshot_from_state(
+    stage_map: list[dict[str, Any]],
+    consumer_state: Any,
+    *,
+    reserved_stages: set[int] | None = None,
+) -> StageLifecycleSnapshot:
+    reserved = set(reserved_stages or set())
+    lifecycles: list[StageLifecycle] = []
+    for stage in stage_map:
+        stage_number = stage["stage_number"]
+        done_row = consumer_state.done_by_stage.get(stage_number) or {}
+        lifecycles.append(StageLifecycle(
+            stage=stage_number,
+            depends_on=list(stage.get("depends_on") or []),
+            done=stage_number in consumer_state.done_stages,
+            started=stage_number in consumer_state.started_stages,
+            reserved=stage_number in reserved,
+            verified_accepted=stage_number in (
+                consumer_state.verified_accepted_stages
+            ),
+            pr_covered=stage_number in consumer_state.pr_covered_stages,
+            head_commit=str(done_row.get("head_commit") or ""),
+            report_path=str(done_row.get("report_path") or ""),
+        ))
+    return StageLifecycleSnapshot(
+        stage_map=stage_map,
+        rows=list(consumer_state.rows),
+        done_rows=list(consumer_state.done_rows),
+        done_by_stage=dict(consumer_state.done_by_stage),
+        done_stages=set(consumer_state.done_stages),
+        started_stages=set(consumer_state.started_stages),
+        reserved_stages=reserved,
+        verified_accepted_stages=set(consumer_state.verified_accepted_stages),
+        pr_covered_stages=set(consumer_state.pr_covered_stages),
+        lifecycles=lifecycles,
+    )
+
+
+def stage_lifecycle_snapshot_from_rows(
+    stage_map: list[dict[str, Any]],
+    rows: list[dict[str, Any]],
+    *,
+    reserved_stages: set[int] | None = None,
+) -> StageLifecycleSnapshot:
+    return stage_lifecycle_snapshot_from_state(
+        stage_map,
+        _stage_consumer_state_from_rows(rows),
+        reserved_stages=reserved_stages,
+    )
+
+
+def read_stage_lifecycle_snapshot(
+    stage_map: list[dict[str, Any]],
+    plan_run_root: Path,
+    *,
+    recover_from_carry: bool = False,
+    reserved_stages: set[int] | None = None,
+) -> StageLifecycleSnapshot:
+    from .consumers import read_stage_consumer_state
+
+    return stage_lifecycle_snapshot_from_state(
+        stage_map,
+        read_stage_consumer_state(
+            plan_run_root,
+            recover_from_carry=recover_from_carry,
+        ),
+        reserved_stages=reserved_stages,
+    )
+
+
 def resolve_effective_stages(
     stages: list[dict[str, Any]],
     done_stages: set[int],

package/runtime/python/okstra_ctl/team_reconcile.py

@@ -15,7 +15,7 @@ recorded pane — those are left for graceful shutdown.
 CC v2.1.178 removed ``TeamDelete``: the implicit team ends with the session and
 run-end teardown only dismisses teammates via ``shutdown_request``. Reconcile
 keeps the roster honest so a dismissed-but-dead member does not linger as a
-live pill — see _common-contract.md "Run-end teammate teardown".
+live pill — see okstra-lead-contract.md "Run-scoped pane & teammate lifecycle".
 
 Roster resolution (``--project-root``) exists because ``team-state.lead.sessionId``
 is a phase-3 snapshot: Claude Code re-issues the session id across resume /

package/runtime/python/okstra_ctl/wizard.py

@@ -12,6 +12,7 @@ Public surface:
 - ``next_prompt()`` - deterministic; pure read on state.
 - ``submit()``      - validate + advance.
 - ``render_args()`` - final args for ``okstra render-bundle``.
+- ``wizard_outcome()`` - final args plus persistence actions and confirmation.
 
 The skill calls these via the ``okstra wizard`` CLI subcommand; it never
 imports this module directly.
@@ -3707,6 +3708,36 @@ def confirmation_block(state: WizardState) -> str:
     return "\n".join(lines)
 
 
+def _wizard_persist_actions(state: WizardState) -> list[dict[str, str]]:
+    if state.task_type != "release-handoff":
+        return []
+    if not state.pr_template_path:
+        return []
+    if state.pr_template_scope not in ("project", "global"):
+        return []
+    return [
+        {
+            "command": "config.set",
+            "key": "pr-template-path",
+            "scope": state.pr_template_scope,
+            "value": state.pr_template_path,
+        }
+    ]
+
+
+def wizard_outcome(state: WizardState) -> dict[str, Any]:
+    """Public outcome for callers that need launch data and follow-up writes."""
+    if state.aborted:
+        raise WizardError("wizard was aborted by the user — outcome is unavailable")
+    if state.confirmed is not True:
+        raise WizardError("wizard is not complete — outcome is unavailable")
+    return {
+        "renderArgs": render_args(state),
+        "persistActions": _wizard_persist_actions(state),
+        "confirmationText": confirmation_block(state),
+    }
+
+
 # ---- File I/O helpers (used by CLI) -------------------------------------
 
 def load_state_file(path: Path) -> WizardState:
@@ -3731,6 +3762,7 @@ def _cli(argv: list[str]) -> int:
       step  --state-file PATH (--answer VALUE | --no-submit)
       render-args --state-file PATH
       confirmation --state-file PATH
+      outcome --state-file PATH
     """
     import argparse
 
@@ -3759,6 +3791,9 @@ def _cli(argv: list[str]) -> int:
     p_conf = sub.add_parser("confirmation")
     p_conf.add_argument("--state-file", required=True)
 
+    p_outcome = sub.add_parser("outcome")
+    p_outcome.add_argument("--state-file", required=True)
+
     args = parser.parse_args(argv)
     state_path = Path(args.state_file)
 
@@ -3836,6 +3871,18 @@ def _cli(argv: list[str]) -> int:
                          ensure_ascii=False, indent=2))
         return 0
 
+    if args.cmd == "outcome":
+        state = load_state_file(state_path)
+        try:
+            out = wizard_outcome(state)
+        except WizardError as exc:
+            print(json.dumps({"ok": False, "error": str(exc)},
+                             ensure_ascii=False, indent=2))
+            return 0
+        print(json.dumps({"ok": True, "outcome": out},
+                         ensure_ascii=False, indent=2))
+        return 0
+
     return 2
 
 

package/runtime/python/okstra_project/__init__.py

@@ -38,6 +38,7 @@ from .state import (
     resolve_task_identity,
     resolve_task_reference,
     slugify,
+    task_read_side_snapshot,
 )
 
 __all__ = [
@@ -64,6 +65,7 @@ __all__ = [
     "resolve_task_identity",
     "resolve_task_reference",
     "slugify",
+    "task_read_side_snapshot",
     "tasks_root",
     "upsert_project_json",
 ]

package/runtime/python/okstra_project/state.py

@@ -37,6 +37,10 @@ from .dirs import (
 class StateError(Exception):
     """state file 읽기/파싱 실패 — 호출자가 surface 해야 할 오류."""
 
+    def __init__(self, message: str, *, stage: Optional[str] = None):
+        super().__init__(message)
+        self.stage = stage
+
 
 def _load_json(path: Path) -> Optional[dict]:
     if not path.is_file():
@@ -268,10 +272,16 @@ def resolve_task_identity(project_root: Path, task_key: str) -> dict:
     """
     task_root = find_task_root(project_root, task_key)
     if task_root is None:
-        raise StateError(f"task root not found for {task_key!r}")
+        raise StateError(
+            f"task root not found for {task_key!r}",
+            stage="task_root_missing",
+        )
     manifest = read_task_manifest(task_root)
     if manifest is None:
-        raise StateError(f"task-manifest.json missing under {task_root}")
+        raise StateError(
+            f"task-manifest.json missing under {task_root}",
+            stage="manifest_missing",
+        )
     workflow = manifest.get("workflow") or {}
     if not isinstance(workflow, dict):
         workflow = {}
@@ -292,3 +302,35 @@ def resolve_task_identity(project_root: Path, task_key: str) -> dict:
         "taskBriefPath": manifest.get("taskBriefPath") or "",
         "manifest": manifest,
     }
+
+
+def task_read_side_snapshot(project_root: Path, task_key: str) -> dict:
+    """task-show / inspect 용 curated task 상태 view 를 반환한다.
+
+    resolve_task_identity 가 내부 raw manifest 를 들고 있지만, 이 accessor 는
+    caller 에게 manifest shape 를 노출하지 않는 read-side 계약이다.
+    """
+    identity = resolve_task_identity(project_root, task_key)
+    manifest = identity["manifest"]
+    workflow = manifest.get("workflow")
+    if not isinstance(workflow, dict):
+        workflow = {}
+    return {
+        "projectRoot": identity["projectRoot"],
+        "taskKey": manifest.get("taskKey"),
+        "taskType": manifest.get("taskType"),
+        "taskRoot": identity["taskRoot"],
+        "taskBriefPath": manifest.get("taskBriefPath"),
+        "workflow": {
+            "currentPhase": workflow.get("currentPhase"),
+            "currentPhaseState": workflow.get("currentPhaseState"),
+            "lastCompletedPhase": workflow.get("lastCompletedPhase"),
+            "nextRecommendedPhase": workflow.get("nextRecommendedPhase"),
+            "routingStatus": workflow.get("routingStatus"),
+            "phaseStates": workflow.get("phaseStates"),
+        },
+        "resultContract": manifest.get("resultContract"),
+        "artifacts": manifest.get("artifacts"),
+        "modelAssignments": manifest.get("modelAssignments"),
+        "latestRunPath": manifest.get("latestRunPath"),
+    }