okstra 0.202.0 → 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

@@ -22,7 +22,13 @@ from .manager_store import (
     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
@@ -37,6 +43,8 @@ _LIST_ROWS = {
                                   ("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"))),
@@ -47,7 +55,8 @@ 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-split",
-               "list-managers", "list-projects", "list-tasks", "view"}
+               "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")]
@@ -94,11 +103,30 @@ def render_manager_text(command: str, payload: dict | list[dict]) -> str:
             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)
 
 
+# 삭제 명령은 --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] = []
@@ -126,10 +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"), ("ticket", "ticketId"), ("brief path", "briefPath"),
+                           ("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
 
 
@@ -188,11 +218,18 @@ _CLI_EPILOG = r"""Usage:
   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."
@@ -277,10 +314,42 @@ def _parser() -> argparse.ArgumentParser:
     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", "tasks"):
+    for name in ("projects", "task-groups", "tasks"):
         list_sub.add_parser(name).add_argument("--manager-id", required=True)
 
     view = sub.add_parser("view")
@@ -391,6 +460,25 @@ def main(argv: list[str] | None = None) -> int:
             _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":

package/runtime/python/okstra_ctl/manager_launch.py

@@ -33,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:

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:

package/runtime/python/okstra_ctl/manager_store.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import json
 import os
+import shutil
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -18,12 +19,17 @@ from okstra_ctl.json_boundary import (
 from .manager_paths import (
     ManagerPathError,
     canonical_manager_id,
+    child_context_path,
     children_json_path,
     directives_jsonl_path,
     events_jsonl_path,
     manager_json_path,
     manager_root,
     projects_json_path,
+    snapshots_json_path,
+    task_group_meta_path,
+    task_group_root,
+    task_groups_root,
     task_manifest_path,
 )
 
@@ -224,11 +230,20 @@ def link_project(
     return payload
 
 
+def _ensure_group_meta(home: Path, manager_id: str, task_group: str, when: str) -> dict:
+    """그룹 폴더와 `group.json` 을 만든다. 이미 있으면 처음 기록을 그대로 둔다."""
+    path = task_group_meta_path(home, manager_id, task_group)
+    if path.is_file():
+        return _read_json(path)
+    meta = {"taskGroup": task_group, "createdAt": when}
+    _write_json(path, meta)
+    return meta
+
+
 def create_task_group(home: Path, manager_id: str, task_group: str, *, now: str | None = None) -> dict:
     load_manager(home, manager_id)
-    group_dir = task_manifest_path(home, manager_id, task_group, "group-marker").parents[1]
-    group_dir.mkdir(parents=True, exist_ok=True)
-    return {"managerId": manager_id, "taskGroup": task_group, "createdAt": now or _now_iso()}
+    meta = _ensure_group_meta(home, manager_id, task_group, now or _now_iso())
+    return {"managerId": manager_id, **meta}
 
 
 def _merge_manifest(existing: dict, requested: dict) -> None:
@@ -313,6 +328,7 @@ def create_task(
         )
     children["children"].extend(added)
     if not existing:
+        _ensure_group_meta(home, manager_id, task_group, when)
         _write_json(manifest_path, manifest)
     _write_json(children_json_path(home, manager_id, task_group, task_id), children)
     append_jsonl(
@@ -423,3 +439,194 @@ def append_directive(
     }
     append_jsonl(directives_jsonl_path(home, manager_id, task_group, task_id), row)
     return row
+
+
+def list_task_groups(home: Path, manager_id: str) -> list[dict]:
+    """태스크가 없는 그룹까지 포함해 그룹을 이름 순으로 돌려준다.
+
+    `group.json` 이 없는 기존 그룹은 소속 태스크 manifest 의 그룹 이름을, 태스크도 없으면
+    폴더 이름을 쓴다.
+    """
+    load_manager(home, manager_id)
+    base = task_groups_root(home, manager_id)
+    if not base.is_dir():
+        return []
+    items: list[dict] = []
+    for group_dir in sorted(path for path in base.iterdir() if path.is_dir()):
+        manifests = sorted(group_dir.glob("*/manifest.json"))
+        meta_path = group_dir / "group.json"
+        meta = _read_json(meta_path) if meta_path.is_file() else {}
+        name = str(meta.get("taskGroup") or "")
+        if not name and manifests:
+            name = str(_read_json(manifests[0]).get("taskGroup") or "")
+        items.append(
+            {
+                "taskGroup": name or group_dir.name,
+                "createdAt": str(meta.get("createdAt") or ""),
+                "taskCount": len(manifests),
+            }
+        )
+    return sorted(items, key=lambda item: item["taskGroup"])
+
+
+def _children_of_project(home: Path, manager_id: str, project_id: str) -> list[tuple[dict, list[str]]]:
+    """(task manifest, 그 task 에서 project_id 를 가리키는 하위 태스크 키) 목록."""
+    rows = []
+    for path in _task_manifest_paths(home, manager_id):
+        children = _read_json_default(path.parent / "children.json", {"children": []})
+        keys = [
+            str(child.get("taskKey"))
+            for child in children.get("children", [])
+            if isinstance(child, dict) and child.get("projectId") == project_id
+        ]
+        if keys:
+            rows.append((_read_json(path), keys))
+    return rows
+
+
+def unlink_project(
+    home: Path, manager_id: str, project_id: str, *, confirm: bool, now: str | None = None
+) -> dict:
+    """프로젝트 등록을 해제한다. 하위 태스크는 남기고, 등록 목록에 없다는 사실로 해제 상태를 표시한다.
+
+    `confirm` 이 거짓이면 대상만 돌려주고 아무것도 바꾸지 않는다.
+    """
+    load_manager(home, manager_id)
+    payload = _load_projects(home, manager_id)
+    entry = _project_entry(payload, project_id)
+    if entry is None:
+        raise ManagerError(f"unknown project membership: {project_id}")
+    affected = _children_of_project(home, manager_id, project_id)
+    result = {
+        "managerId": manager_id,
+        "projectId": project_id,
+        "projectRoot": str(entry.get("projectRoot") or ""),
+        "keptChildren": [key for _, keys in affected for key in keys],
+        "removed": confirm,
+    }
+    if not confirm:
+        return result
+    payload["projects"] = [item for item in payload["projects"] if item is not entry]
+    _write_json(projects_json_path(home, manager_id), payload)
+    when = now or _now_iso()
+    for manifest, keys in affected:
+        append_jsonl(
+            events_jsonl_path(home, manager_id, str(manifest["taskGroup"]), str(manifest["taskId"])),
+            {"event": "project-unlinked", "createdAt": when, "projectId": project_id, "taskKeys": keys},
+        )
+    return result
+
+
+def remove_child(
+    home: Path,
+    manager_id: str,
+    task_group: str,
+    task_id: str,
+    project_id: str,
+    *,
+    child_task_id: str | None = None,
+    confirm: bool,
+    now: str | None = None,
+) -> dict:
+    """하위 태스크 하나를 manager 에서 뺀다. 프로젝트의 `.okstra/` 는 건드리지 않는다."""
+    _read_json(task_manifest_path(home, manager_id, task_group, task_id))
+    payload = _load_children(home, manager_id, task_group, task_id)
+    child = _select_child_for_assignment(payload["children"], project_id, task_group, child_task_id)
+    task_key = str(child.get("taskKey") or "")
+    result = {"managerId": manager_id, "taskGroup": task_group, "taskId": task_id,
+              "taskKey": task_key, "removed": confirm}
+    if not confirm:
+        return result
+    payload["children"] = [item for item in payload["children"] if item is not child]
+    _write_json(children_json_path(home, manager_id, task_group, task_id), payload)
+    # 남은 형제의 context 에 지운 하위 태스크가 형제로 실리지 않게 스냅샷 행도 뺀다.
+    snapshot_path = snapshots_json_path(home, manager_id, task_group, task_id)
+    if snapshot_path.is_file():
+        snapshot = _read_json(snapshot_path)
+        snapshot["children"] = [
+            row for row in snapshot.get("children", []) if not isinstance(row, dict) or row.get("taskKey") != task_key
+        ]
+        _write_json(snapshot_path, snapshot)
+    child_context_path(
+        home, manager_id, task_group, task_id, project_id, str(child.get("taskId") or task_id)
+    ).unlink(missing_ok=True)
+    append_jsonl(
+        events_jsonl_path(home, manager_id, task_group, task_id),
+        {"event": "task-child-removed", "createdAt": now or _now_iso(), "taskKey": task_key},
+    )
+    return result
+
+
+def update_task(
+    home: Path,
+    manager_id: str,
+    task_group: str,
+    task_id: str,
+    *,
+    objective: str | None = None,
+    common_brief_path: str | None = None,
+    progress_mode: str | None = None,
+    now: str | None = None,
+) -> dict:
+    """manager task 의 objective·공통 브리프·진행 방식 중 넘긴 값만 바꾼다."""
+    manifest_path = task_manifest_path(home, manager_id, task_group, task_id)
+    manifest = _read_json(manifest_path)
+    requested = {"objective": objective, "commonBriefPath": common_brief_path, "progressMode": progress_mode}
+    requested = {key: value for key, value in requested.items() if value is not None}
+    if not requested:
+        raise ManagerError("task update needs at least one of --objective, --common-brief, --progress-mode")
+    if requested.get("progressMode") not in (None, "manual", "auto"):
+        raise ManagerError("progress-mode must be manual or auto")
+    changes = {
+        key: {"from": manifest.get(key), "to": value}
+        for key, value in requested.items()
+        if manifest.get(key) != value
+    }
+    for key, change in changes.items():
+        manifest[key] = change["to"]
+    if changes:
+        _write_json(manifest_path, manifest)
+        append_jsonl(
+            events_jsonl_path(home, manager_id, task_group, task_id),
+            {"event": "task-updated", "createdAt": now or _now_iso(), "changes": changes},
+        )
+    return {"manifest": manifest, "changedFields": sorted(changes)}
+
+
+def remove_task(
+    home: Path, manager_id: str, task_group: str, task_id: str, *, confirm: bool
+) -> dict:
+    """manager task 폴더를 지운다. 하위 프로젝트의 태스크와 브리프는 남는다."""
+    manifest = _read_json(task_manifest_path(home, manager_id, task_group, task_id))
+    root = task_manifest_path(home, manager_id, task_group, task_id).parent
+    children = _load_children(home, manager_id, task_group, task_id)["children"]
+    result = {
+        "managerId": manager_id,
+        "taskGroup": str(manifest.get("taskGroup") or task_group),
+        "taskId": str(manifest.get("taskId") or task_id),
+        "path": str(root),
+        "childCount": len(children),
+        "removed": confirm,
+    }
+    if confirm:
+        shutil.rmtree(root)
+    return result
+
+
+def remove_task_group(home: Path, manager_id: str, task_group: str, *, confirm: bool) -> dict:
+    """그룹 폴더와 그 안의 manager task 전부를 지운다."""
+    load_manager(home, manager_id)
+    root = task_group_root(home, manager_id, task_group)
+    if not root.is_dir():
+        raise ManagerError(f"unknown task group: {task_group}")
+    task_ids = [str(_read_json(path).get("taskId") or path.parent.name) for path in sorted(root.glob("*/manifest.json"))]
+    result = {
+        "managerId": manager_id,
+        "taskGroup": task_group,
+        "path": str(root),
+        "taskIds": task_ids,
+        "removed": confirm,
+    }
+    if confirm:
+        shutil.rmtree(root)
+    return result

package/runtime/python/okstra_ctl/manager_sync.py

@@ -109,7 +109,7 @@ def sync_task(home: Path, manager_id: str, task_group: str, task_id: str, *, now
             continue
         project = projects.get(str(child.get("projectId") or ""))
         if project is None:
-            rows.append({**child, "exists": False, "error": "unknown project membership"})
+            rows.append({**child, "exists": False, "error": "project unlinked from this manager; re-register it with `okstra manager new project`"})
             continue
         root = Path(str(project.get("projectRoot") or ""))
         if not root.is_dir():
@@ -160,6 +160,7 @@ def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> d
     children = _read_json_default(children_json_path(home, manager_id, task_group, task_id), {"children": []})
     snapshot = _read_json_default(snapshots_json_path(home, manager_id, task_group, task_id), {"children": []})
     by_key = {row.get("taskKey"): row for row in snapshot.get("children", []) if isinstance(row, dict)}
+    linked = _project_map(home, manager_id)
     rows = []
     summary = {"planned": 0, "missing": 0, "running": 0, "done": 0, "blocked": 0}
     for child in children.get("children", []):
@@ -168,6 +169,8 @@ def status_task(home: Path, manager_id: str, task_group: str, task_id: str) -> d
         snapshot_row = by_key.get(child.get("taskKey"))
         row = {**child, **(snapshot_row or {})}
         row["summaryBucket"] = "planned" if snapshot_row is None else summary_bucket(row)
+        # `remove project` 는 하위 태스크를 남긴다. 등록 목록에 없으면 해제된 프로젝트의 것이다.
+        row["projectLinked"] = str(child.get("projectId") or "") in linked
         summary[row["summaryBucket"]] += 1
         rows.append(row)
     return {"manifest": manifest, "summary": summary, "children": rows, "lastSnapshot": snapshot}

package/runtime/python/okstra_ctl/manager_view.py

@@ -95,7 +95,8 @@ def _child_rows(children: list[dict], roots: dict[str, str]) -> list[list[str]]:
         assignment = assignment or "; ".join(child.get("scope") or [])
         rows.append(
             [
-                f"<code>{_e(child.get('taskKey'))}</code>",
+                f"<code>{_e(child.get('taskKey'))}</code>"
+                + ("" if child.get("projectLinked", True) else " " + _chip("unlinked")),
                 _e(child.get("ticketId") or "-"),
                 _chip(str(child.get("summaryBucket") or "planned")),
                 _e(child.get("workStatus") or "-"),