okstra 0.201.3 → 0.204.0

package/runtime/python/okstra_ctl/initial_prompt_materialization.py

@@ -131,6 +131,8 @@ _REQUIRED_PROMPT_RESOURCES_HEADING = "## Required prompt resources"
 _HTML_COMMENTS = re.compile(r"<!--.*?-->\n?", re.DOTALL)
 _AGENT_CONTRACT_KEYS = {
     "schemaVersion",
+    # 이 run 이 동결한 계약 형식. 없는 run 은 Markdown 직무를 동결했다.
+    "contractFormatVersion",
     "dutyRootPath",
     "catalogDigest",
     "invocationReservationRootPath",
@@ -214,6 +216,117 @@ def materialize_initial_prompts(
         ) from exc
 
 
+def declared_delivery_mode(manifest: Mapping[str, Any]) -> PromptDeliveryMode:
+    """이 run 의 어댑터가 선언한 초기 프롬프트 배송 방식.
+
+    선언은 `leadAdapter.initialPromptDeliveryMode` 에 있고, 그 값은 render 가
+    호스트 descriptor(어댑터가 워커 디스패치를 가져갔으면 그 어댑터)에서
+    옮겨 적은 것이다. 선언이 없는 매니페스트는 이 필드가 생기기 전에 준비된
+    run 이므로 그때의 동작인 `eager-include` 로 간다. 아는 값이 아니면 멈춘다 —
+    프롬프트를 발행하고 나면 그 프롬프트는 불변이라, 잘못 고른 배송 방식은
+    나중에 고칠 수 없다.
+    """
+    adapter = manifest.get("leadAdapter")
+    declared = (
+        _string_value(adapter.get("initialPromptDeliveryMode"))
+        if isinstance(adapter, Mapping)
+        else ""
+    )
+    if not declared:
+        return PromptDeliveryMode.EAGER_INCLUDE
+    try:
+        return PromptDeliveryMode(declared)
+    except ValueError:
+        allowed = ", ".join(mode.value for mode in PromptDeliveryMode)
+        raise InitialPromptMaterializationError(
+            "required_input_missing",
+            "leadAdapter.initialPromptDeliveryMode is not a delivery mode: "
+            f"{declared!r} (allowed: {allowed})",
+        ) from None
+
+
+def _read_side_context(
+    project_root: Path, run_manifest_path: Path, runtime_root: Path,
+) -> "_MaterializationContext":
+    """프롬프트를 쓰지 않는 호출자를 위한 컨텍스트.
+
+    읽는 것은 매니페스트·active run context·런타임 루트뿐이다. 발행 권한 검사와
+    team-state 는 프롬프트를 쓰는 쪽(호출한 CLI)의 몫이다.
+    """
+    root = project_root.resolve()
+    manifest = _load_json_object(
+        _resolve_input_path(root, run_manifest_path), "run manifest"
+    )
+    return _MaterializationContext(
+        request=InitialPromptMaterializationRequest(
+            project_root=root,
+            run_manifest_path=run_manifest_path,
+            runtime_root=runtime_root,
+            delivery_mode=declared_delivery_mode(manifest),
+            workers=(),
+        ),
+        project_root=root,
+        manifest=manifest,
+        team_state={},
+        active_context=hydrate_active_run_context(
+            _load_referenced_json(root, manifest, "activeRunContextPath")
+        ),
+    )
+
+
+def implementation_anchor_lines(
+    *,
+    project_root: Path,
+    run_manifest_path: Path,
+    runtime_root: Path,
+    worker_id: str,
+) -> list[str]:
+    """이 워커의 프롬프트가 싣는 구현 앵커 줄. 구현 audience 가 아니면 빈 목록.
+
+    executor 의 mutating cwd, 그리고 executor·verifier 공통의
+    `**Approved plan:**` / `**Stage for this implementation run:**` 이다.
+    `okstra agent-prompt jobs` 는 이 두 헤더를 요구하므로, 리드가 회수 경로로
+    발행한 프롬프트는 그 검사에서 거절됐다(실측 2026-09-23, fontradar-v2-api
+    dev-10860 stage-3: 리드가 헤더 두 줄을 손으로 지시문에 붙여 통과시켰다).
+    """
+    context = _read_side_context(project_root, run_manifest_path, runtime_root)
+    return _implementation_anchor_lines(
+        context, _prompt_plan(context.manifest, worker_id)
+    )
+
+
+def required_resource_block(
+    *,
+    project_root: Path,
+    run_manifest_path: Path,
+    runtime_root: Path,
+    worker_id: str,
+) -> str:
+    """이 워커의 프롬프트가 싣는 필수 자원 블록. 없으면 빈 문자열.
+
+    디스패치 시점의 composer 와 같은 블록이다 — executor 는 BLOCKING 게이트 세
+    본문과 stage discipline, verifier 는 `_implementation-verifier.md`, 둘 다
+    clarification 권한 블록과 fix-run carry. 리드가 `okstra agent-prompt
+    materialize` 로 먼저 발행한 프롬프트는 디스패치가 기존 파일로 그대로 쓰므로
+    composer 가 돌지 않았고, 이 블록이 통째로 빠졌다(실측 2026-09-22,
+    fontradar-v2-api dev-10860 implementation stage-1: executor·verifier 4개
+    프롬프트 모두 0건). 그 명령이 이 함수로 같은 블록을 붙인다.
+    """
+    context = _read_side_context(project_root, run_manifest_path, runtime_root)
+    plan = _prompt_plan(context.manifest, worker_id)
+    item = _PromptItem(
+        worker=InitialPromptWorkerRequest(worker_id, ""),
+        final_path=Path(),
+        plan=plan,
+        existed=False,
+        clarification_input=_resolve_clarification_input(context, plan),
+    )
+    item = _with_prompt_resources(
+        item, _resolve_prompt_resources(context, plan, existed=False)
+    )
+    return "\n".join(_resource_lines(context, item)).strip()
+
+
 def _materialize_initial_prompts(
     request: InitialPromptMaterializationRequest,
 ) -> dict[str, Path]:

package/runtime/python/okstra_ctl/lead_progress.py

@@ -243,7 +243,7 @@ def _append(args: argparse.Namespace) -> int:
 
 _CLI_EPILOG = r"""Usage:
   okstra lead-progress append --project-root <dir> --run-manifest <path> --phase phase-1-intake
-  okstra lead-progress append --project-root <dir> --run-manifest <path> --phase phase-4-dispatch --worker codex-worker --field model=gpt-5.6-sol
+  okstra lead-progress append --project-root <dir> --run-manifest <path> --phase phase-4-dispatch --worker codex-worker --field model=gpt-6-sol
   okstra lead-progress append --project-root <dir> --run-manifest <path> --phase phase-5-collect --worker codex-worker --field status=completed
 
 `progressLine` in the output is the line to emit to the user, verbatim.

package/runtime/python/okstra_ctl/legacy_model_selection.py

@@ -11,7 +11,7 @@ from .domain.host import (
     HostSessionContext,
 )
 from .domain.role import RoleCatalogError, normalize_role
-from .role_requirements import RoleProfile, RoleRequirement
+from .role_requirements import RoleProfile, RoleRequirement, StaticRoleRequirement
 
 
 class ModelSelectionInputError(ValueError):
@@ -404,7 +404,7 @@ def _validate_selection(
     explicit_counts: Mapping[str, int],
 ) -> None:
     requirements = {row.role: row for row in profile.roles if not row.dynamic}
-    requirements["leader"] = RoleRequirement("leader", 1, 1, 1, "lead")
+    requirements["leader"] = StaticRoleRequirement("leader", 1, 1, 1, "lead")
     for role in sorted(set(counts) | set(models)):
         requirement = requirements.get(role)
         if requirement is None:

package/runtime/python/okstra_ctl/manager_cli.py

@@ -10,6 +10,7 @@ from okstra_project.dirs import okstra_home
 
 from .manager_launch import build_launch_packet
 from .fixed_text import line, value_lines
+from .manager_paths import ManagerPathError
 from .manager_store import (
     ManagerError,
     append_directive,
@@ -19,20 +20,49 @@ from .manager_store import (
     discover_projects,
     init_manager,
     link_project,
+    list_managers,
+    list_projects,
+    list_task_groups,
+    list_tasks,
+    remove_child,
+    remove_task,
+    remove_task_group,
+    unlink_project,
+    update_task,
 )
+from .manager_split import split_task
 from .manager_sync import status_task, sync_task
+from .manager_view import write_view
+
+# list 명령마다 목록 한 줄에 싣는 (라벨, 키). 라벨은 "<접두어> <번호> <라벨>" 로 찍힌다.
+_LIST_ROWS = {
+    "discover-projects": ("Project", (("ID", "projectId"), ("root", "projectRoot"),
+                                      ("run count", "runCount"), ("active count", "activeCount"),
+                                      ("last run at", "lastRunAt"))),
+    "list-managers": ("Manager", (("ID", "managerId"), ("created at", "createdAt"),
+                                  ("project count", "projectCount"), ("task count", "taskCount"))),
+    "list-projects": ("Project", (("ID", "projectId"), ("root", "projectRoot"), ("role", "role"),
+                                  ("tags", "tags"), ("linked at", "linkedAt"))),
+    "list-task-groups": ("Task group", (("name", "taskGroup"), ("created at", "createdAt"),
+                                        ("task count", "taskCount"))),
+    "list-tasks": ("Task", (("group", "taskGroup"), ("ID", "taskId"), ("objective", "objective"),
+                            ("progress mode", "progressMode"), ("child count", "childCount"),
+                            ("created at", "createdAt"))),
+}
 
 
 def render_manager_text(command: str, payload: dict | list[dict]) -> str:
     """manager 모델 표면에 승인된 식별자와 상태만 투영한다."""
     allowed = {"init", "discover-projects", "new-project", "new-task-group", "new-task",
-               "task-assign", "task-note", "task-sync", "task-status", "task-run"}
+               "task-assign", "task-note", "task-sync", "task-status", "task-run", "task-split",
+               "list-managers", "list-projects", "list-task-groups", "list-tasks", "view",
+               "task-update", "task-remove-child", "remove-project", "remove-task", "remove-task-group"}
     if command not in allowed:
         raise ValueError("unknown manager text purpose")
     rows = [f"Okstra manager {command}\n", line("Status", "ready")]
     if isinstance(payload, list):
         rows.append(line("Result count", len(payload)))
-        rows.extend(_render_manager_projects(payload))
+        rows.extend(_render_list(command, payload))
         return "".join(rows)
     if command == "task-status":
         rows.extend(_render_manager_status(payload))
@@ -44,7 +74,9 @@ def render_manager_text(command: str, payload: dict | list[dict]) -> str:
                        ("Work status", "workStatus"), ("Run command", "command"),
                        ("Backend", "backend"),
                        ("Worker dispatch backend", "workerDispatchBackend"),
-                       ("Project root", "projectRoot"), ("Context path", "contextPath")):
+                       ("Project root", "projectRoot"), ("Context path", "contextPath"),
+                       ("Shell command", "shellCommand"), ("View path", "viewPath"),
+                       ("View URL", "viewUrl")):
         if key in payload:
             rows.append(line(label, payload.get(key)))
     run_args = payload.get("runArgs")
@@ -64,20 +96,46 @@ def render_manager_text(command: str, payload: dict | list[dict]) -> str:
                            ("Directive body", "body"), ("Created at", "createdAt"),
                            ("Source", "source")):
             rows.append(line(label, payload.get(key)))
+    if command == "task-split":
+        briefs = payload.get("briefs") if isinstance(payload.get("briefs"), list) else []
+        rows.append(line("Brief count", len(briefs)))
+        for index, brief in enumerate(briefs, 1):
+            for label, key in (("task key", "taskKey"), ("project ID", "projectId"), ("ticket", "ticketId"),
+                               ("path", "briefPath"), ("status", "briefStatus")):
+                rows.append(line(f"Brief {index} {label}", brief.get(key)))
+    if command == "task-update":
+        rows.append(line("Changed fields", ", ".join(payload.get("changedFields") or []) or "none"))
+        rows.extend(value_lines("Manifest", payload.get("manifest")))
+    if command.startswith("remove-") or command == "task-remove-child":
+        rows.extend(_render_removal(payload))
     if command == "task-sync" and "syncedAt" in payload:
         rows.append(line("Synced at", payload.get("syncedAt")))
     return "".join(rows)
 
 
-def _render_manager_projects(projects: list[dict]) -> list[str]:
+# 삭제 명령은 --confirm 이 없으면 대상만 보여 준다. 무엇이 지워지고 무엇이 남는지 한 줄씩 찍는다.
+def _render_removal(payload: dict) -> list[str]:
+    rows = [line("Removed", "yes" if payload.get("removed") else "no — dry run; rerun with --confirm")]
+    for label, key in (("Removed path", "path"), ("Child count", "childCount")):
+        if key in payload:
+            rows.append(line(label, payload.get(key)))
+    for label, key in (("Kept child", "keptChildren"), ("Removed task", "taskIds")):
+        values = payload.get(key)
+        if isinstance(values, list):
+            rows.append(line(f"{label} count", len(values)))
+            rows.extend(line(f"{label} {index}", value) for index, value in enumerate(values, 1))
+    return rows
+
+
+def _render_list(command: str, items: list[dict]) -> list[str]:
+    prefix, fields = _LIST_ROWS[command]
     rows: list[str] = []
-    for index, project in enumerate(projects, 1):
-        if not isinstance(project, dict):
+    for index, item in enumerate(items, 1):
+        if not isinstance(item, dict):
             continue
-        for label, key in (("ID", "projectId"), ("root", "projectRoot"),
-                           ("run count", "runCount"), ("active count", "activeCount"),
-                           ("last run at", "lastRunAt")):
-            rows.append(line(f"Project {index} {label}", project.get(key)))
+        for label, key in fields:
+            value = item.get(key)
+            rows.append(line(f"{prefix} {index} {label}", ", ".join(value) if isinstance(value, list) else value))
     return rows
 
 
@@ -96,9 +154,12 @@ def _render_manager_status(payload: dict) -> list[str]:
             continue
         for label, key in (("task key", "taskKey"), ("run status", "latestRunStatus"),
                            ("current phase", "currentPhase"), ("work status", "workStatus"),
+                           ("summary", "summaryBucket"), ("project linked", "projectLinked"),
+                           ("ticket", "ticketId"), ("brief path", "briefPath"),
                            ("report path", "latestReportRecordPath"), ("error", "error")):
             if key in child:
-                rows.append(line(f"Child {index} {label}", child.get(key)))
+                value = child.get(key)
+                rows.append(line(f"Child {index} {label}", ("yes" if value else "no") if isinstance(value, bool) else value))
     return rows
 
 
@@ -156,7 +217,19 @@ _CLI_EPILOG = r"""Usage:
   okstra manager task assign --manager-id <id> --task-group <task-group> --task-id <task-id> --project-id <project-id>
   okstra manager task note --manager-id <id> --task-group <task-group> --task-id <task-id> --scope <shared|project> --body <text>
   okstra manager task run --manager-id <id> --project-id <project-id> --task-group <task-group> --task-id <task-id>
-
+  okstra manager task split --manager-id <id> --task-group <task-group> --task-id <task-id> --plan <split-plan.json> [--overwrite]
+  okstra manager task update --manager-id <id> --task-group <task-group> --task-id <task-id> [--objective <text>] [--common-brief <path>] [--progress-mode <manual|auto>]
+  okstra manager task remove-child --manager-id <id> --task-group <task-group> --task-id <task-id> --project-id <project-id> [--child-task-id <id>] [--confirm]
+  okstra manager remove project --manager-id <id> --project-id <project-id> [--confirm]
+  okstra manager remove task --manager-id <id> --task-group <task-group> --task-id <task-id> [--confirm]
+  okstra manager remove task-group --manager-id <id> --task-group <task-group> [--confirm]
+  okstra manager list managers
+  okstra manager list projects --manager-id <id>
+  okstra manager list task-groups --manager-id <id>
+  okstra manager list tasks --manager-id <id>
+  okstra manager view --manager-id <id>
+
+  remove and task remove-child only show their targets unless --confirm is given.
   --workspace-root is owned by this command.
 """
 _CLI_DESCRIPTION = "Manage cross-project okstra tasks."
@@ -198,7 +271,7 @@ def _parser() -> argparse.ArgumentParser:
     task_new.add_argument("--task", action="append", default=[])
     task_new.add_argument("--objective", default="")
     task_new.add_argument("--common-brief", default="")
-    task_new.add_argument("--progress-mode", choices=["manual", "auto"], default="manual")
+    task_new.add_argument("--progress-mode", choices=["manual", "auto"], default=None)
 
     task = sub.add_parser("task")
     task_sub = task.add_subparsers(dest="task_command", required=True)
@@ -233,6 +306,54 @@ def _parser() -> argparse.ArgumentParser:
     run.add_argument("--task-group", required=True)
     run.add_argument("--task-id", required=True)
     run.add_argument("--child-task-id", default=None)
+
+    split = task_sub.add_parser("split")
+    split.add_argument("--manager-id", required=True)
+    split.add_argument("--task-group", required=True)
+    split.add_argument("--task-id", required=True)
+    split.add_argument("--plan", required=True)
+    split.add_argument("--overwrite", action="store_true")
+
+    update = task_sub.add_parser("update")
+    update.add_argument("--manager-id", required=True)
+    update.add_argument("--task-group", required=True)
+    update.add_argument("--task-id", required=True)
+    update.add_argument("--objective", default=None)
+    update.add_argument("--common-brief", default=None)
+    update.add_argument("--progress-mode", choices=["manual", "auto"], default=None)
+
+    remove_child_cmd = task_sub.add_parser("remove-child")
+    remove_child_cmd.add_argument("--manager-id", required=True)
+    remove_child_cmd.add_argument("--task-group", required=True)
+    remove_child_cmd.add_argument("--task-id", required=True)
+    remove_child_cmd.add_argument("--project-id", required=True)
+    remove_child_cmd.add_argument("--child-task-id", default=None)
+    remove_child_cmd.add_argument("--confirm", action="store_true")
+
+    remove = sub.add_parser("remove")
+    remove_sub = remove.add_subparsers(dest="remove_command", required=True)
+    remove_project = remove_sub.add_parser("project")
+    remove_project.add_argument("--manager-id", required=True)
+    remove_project.add_argument("--project-id", required=True)
+    remove_project.add_argument("--confirm", action="store_true")
+    remove_task_cmd = remove_sub.add_parser("task")
+    remove_task_cmd.add_argument("--manager-id", required=True)
+    remove_task_cmd.add_argument("--task-group", required=True)
+    remove_task_cmd.add_argument("--task-id", required=True)
+    remove_task_cmd.add_argument("--confirm", action="store_true")
+    remove_group = remove_sub.add_parser("task-group")
+    remove_group.add_argument("--manager-id", required=True)
+    remove_group.add_argument("--task-group", required=True)
+    remove_group.add_argument("--confirm", action="store_true")
+
+    listing = sub.add_parser("list")
+    list_sub = listing.add_subparsers(dest="list_command", required=True)
+    list_sub.add_parser("managers")
+    for name in ("projects", "task-groups", "tasks"):
+        list_sub.add_parser(name).add_argument("--manager-id", required=True)
+
+    view = sub.add_parser("view")
+    view.add_argument("--manager-id", required=True)
     return parser
 
 
@@ -322,11 +443,51 @@ def main(argv: list[str] | None = None) -> int:
                 ),
                 args.json,
             )
+        elif args.command == "task" and args.task_command == "split":
+            _emit(
+                "task-split",
+                split_task(
+                    home,
+                    args.manager_id,
+                    args.task_group,
+                    args.task_id,
+                    Path(args.plan),
+                    overwrite=args.overwrite,
+                ),
+                args.json,
+            )
+        elif args.command == "list" and args.list_command == "managers":
+            _emit("list-managers", list_managers(home), args.json)
+        elif args.command == "list" and args.list_command == "projects":
+            _emit("list-projects", list_projects(home, args.manager_id), args.json)
+        elif args.command == "task" and args.task_command == "update":
+            _emit("task-update", update_task(home, args.manager_id, args.task_group, args.task_id,
+                                             objective=args.objective, common_brief_path=args.common_brief,
+                                             progress_mode=args.progress_mode), args.json)
+        elif args.command == "task" and args.task_command == "remove-child":
+            _emit("task-remove-child", remove_child(home, args.manager_id, args.task_group, args.task_id,
+                                                    args.project_id, child_task_id=args.child_task_id,
+                                                    confirm=args.confirm), args.json)
+        elif args.command == "remove" and args.remove_command == "project":
+            _emit("remove-project", unlink_project(home, args.manager_id, args.project_id,
+                                                   confirm=args.confirm), args.json)
+        elif args.command == "remove" and args.remove_command == "task":
+            _emit("remove-task", remove_task(home, args.manager_id, args.task_group, args.task_id,
+                                             confirm=args.confirm), args.json)
+        elif args.command == "remove" and args.remove_command == "task-group":
+            _emit("remove-task-group", remove_task_group(home, args.manager_id, args.task_group,
+                                                         confirm=args.confirm), args.json)
+        elif args.command == "list" and args.list_command == "task-groups":
+            _emit("list-task-groups", list_task_groups(home, args.manager_id), args.json)
+        elif args.command == "list" and args.list_command == "tasks":
+            _emit("list-tasks", list_tasks(home, args.manager_id), args.json)
+        elif args.command == "view":
+            _emit("view", write_view(home, args.manager_id), args.json)
         else:
             parser.print_help()
             return 2
         return 0
-    except ManagerError as exc:
+    except (ManagerError, ManagerPathError) as exc:
         print(f"okstra manager: {exc}", file=sys.stderr)
         return 2
 

package/runtime/python/okstra_ctl/manager_launch.py

@@ -1,6 +1,7 @@
 """Build manager child launch packets and context documents."""
 from __future__ import annotations
 
+import shlex
 from pathlib import Path
 
 from okstra_ctl.jsonl import append_jsonl, read_jsonl
@@ -15,12 +16,16 @@ from .manager_paths import (
     task_manifest_path,
 )
 from .manager_store import ManagerError, _now_iso, _read_json, _read_json_default, _write_json
+from .manager_sync import _resolve_task_root_read_only
 
 
 WORKER_DISPATCH_BACKEND = "subagent"
-# child lead 는 언제나 subagent 로 뜬다. 예전에는 `$TMUX` 가 잡히면
-# `tmux-child-lead` 를 골랐지만 tmux 백엔드가 사라져 분기가 남지 않았다.
-CHILD_LEAD_BACKEND = "subagent-child-lead"
+# child lead 는 설치본 런처(`okstra.sh`)가 새 host 프로세스로 띄운다. `okstra run`
+# 은 lead host 에 `--launch-only` 를 붙여 task 인자와 `--directive` 를 버리므로
+# child 맥락이 전달되지 않는다(run.mts 의 launch-lead 분기). 런처는 prepare 까지
+# 거친 뒤 `launch-plan --entry-mode spawn-process` 로 lead 를 띄운다.
+CHILD_LEAD_BACKEND = "spawn-process"
+LAUNCHER_RELATIVE = Path("bin") / "okstra.sh"
 LAUNCH_STATUS_PREPARED = "prepared"
 
 
@@ -28,7 +33,7 @@ def _find_project(projects: dict, project_id: str) -> dict:
     for project in projects.get("projects", []):
         if isinstance(project, dict) and project.get("projectId") == project_id:
             return project
-    raise ManagerError(f"unknown project membership: {project_id}")
+    raise ManagerError(f"{project_id}: project unlinked from this manager; re-register it with `okstra manager new project`")
 
 
 def _target_task_key(project_id: str, task_group: str, task_id: str) -> str:
@@ -110,9 +115,14 @@ def _render_context(
         "",
         child.get("assignment") or "",
         "",
-        "## Manager Directives",
-        "",
     ]
+    if child.get("scope"):
+        # `task split` 이 만든 하위 태스크. 이 프로젝트에서 할 범위만 적는다.
+        lines.extend(["## Project Scope", "", f"- ticket: {child.get('ticketId') or ''}",
+                      f"- brief: {child.get('briefPath') or ''}", ""])
+        lines.extend(f"- in scope: {item}" for item in child["scope"])
+        lines.append("")
+    lines.extend(["## Manager Directives", ""])
     for row in directives:
         lines.append(f"- [{row.get('scope')}] {row.get('body')}")
     if not directives:
@@ -214,6 +224,28 @@ def build_launch_packet(
         ),
         encoding="utf-8",
     )
+    command = str(Path(home) / LAUNCHER_RELATIVE)
+    run_args = [
+        "--project-root",
+        project_root,
+        "--project-id",
+        project_id,
+        "--task-group",
+        str(child.get("taskGroup") or task_group),
+        "--task-id",
+        child_task_id_value,
+    ]
+    # `task split` 이 기록한 브리프·권장 phase 를 넘겨 런처가 첫 실행에서 다시 묻지 않게 한다.
+    # phase 는 하위 태스크가 아직 없을 때만 넘긴다. 이미 있으면 런처가 manifest 에서 다음
+    # phase 를 채워야 하는데, 두 값이 다 주어지면 그 채우기를 건너뛴다(autofill_from_manifest).
+    if child.get("recommendedPhase") and _resolve_task_root_read_only(Path(project_root), target_task_key) is None:
+        run_args.extend(["--task-type", str(child["recommendedPhase"])])
+    if child.get("briefPath"):
+        run_args.extend(["--task-brief", str(child["briefPath"])])
+    run_args += [
+        "--directive",
+        f"Read manager child context: {context_path}",
+    ]
     packet = {
         "managerId": manager_id,
         "taskGroup": task_group,
@@ -224,19 +256,9 @@ def build_launch_packet(
         "workerDispatchBackend": WORKER_DISPATCH_BACKEND,
         "projectRoot": project_root,
         "contextPath": str(context_path),
-        "runArgs": [
-            "run",
-            "--project-root",
-            project_root,
-            "--project-id",
-            project_id,
-            "--task-group",
-            str(child.get("taskGroup") or task_group),
-            "--task-id",
-            child_task_id_value,
-            "--directive",
-            f"Read manager child context: {context_path}",
-        ],
+        "command": command,
+        "runArgs": run_args,
+        "shellCommand": shlex.join([command, *run_args]),
         "createdAt": created_at,
     }
     _record_launch_prepared(

package/runtime/python/okstra_ctl/manager_paths.py

@@ -54,10 +54,21 @@ def manager_root(home: Path, manager_id: str) -> Path:
     return Path(home) / "managers" / canonical_manager_id(manager_id)
 
 
+def task_groups_root(home: Path, manager_id: str) -> Path:
+    return manager_root(home, manager_id) / "task-groups"
+
+
+def task_group_root(home: Path, manager_id: str, task_group: str) -> Path:
+    return task_groups_root(home, manager_id) / _slug_segment(task_group, "task-group")
+
+
+def task_group_meta_path(home: Path, manager_id: str, task_group: str) -> Path:
+    """폴더 이름은 slug 라 원래 그룹 이름을 여기에 남긴다."""
+    return task_group_root(home, manager_id, task_group) / "group.json"
+
+
 def task_root(home: Path, manager_id: str, task_group: str, task_id: str) -> Path:
-    group_segment = _slug_segment(task_group, "task-group")
-    task_segment = _slug_segment(task_id, "task-id")
-    return manager_root(home, manager_id) / "task-groups" / group_segment / task_segment
+    return task_group_root(home, manager_id, task_group) / _slug_segment(task_id, "task-id")
 
 
 def manager_json_path(home: Path, manager_id: str) -> Path:
@@ -84,6 +95,10 @@ def snapshots_json_path(home: Path, manager_id: str, task_group: str, task_id: s
     return task_root(home, manager_id, task_group, task_id) / "snapshots.json"
 
 
+def split_plan_path(home: Path, manager_id: str, task_group: str, task_id: str) -> Path:
+    return task_root(home, manager_id, task_group, task_id) / "split-plan.json"
+
+
 def events_jsonl_path(home: Path, manager_id: str, task_group: str, task_id: str) -> Path:
     return task_root(home, manager_id, task_group, task_id) / "events.jsonl"
 
@@ -99,3 +114,7 @@ def child_context_path(
     safe_project = _slug_segment(project_id, "project-id")
     safe_task = _slug_segment(child_task_id, "task-id")
     return task_root(home, manager_id, task_group, task_id) / "child-context" / f"{safe_project}-{safe_task}.md"
+
+
+def view_html_path(home: Path, manager_id: str) -> Path:
+    return manager_root(home, manager_id) / "view" / "index.html"