okstra 0.38.1 → 0.40.0

package/runtime/python/okstra_ctl/seeding.py

@@ -14,12 +14,6 @@ import time
 from pathlib import Path
 from typing import Optional
 
-from okstra_project.dirs import (
-    CLAUDE_MD_IMPORT_LINE,
-    CLAUDE_MD_SYMLINK_RELATIVE,
-    OKSTRA_DIR_NAME,
-)
-
 
 class InstallationError(Exception):
     """okstra 가 깔아둔 런타임 자산이 누락됨."""
@@ -29,14 +23,6 @@ class SettingsLinkError(Exception):
     """`<project>/.claude/settings.local.json` symlink provisioning 실패."""
 
 
-class ClaudeMdLinkError(Exception):
-    """okstra-relative `CLAUDE.md` symlink or import-block provisioning 실패."""
-
-
-class AgentsMdLinkError(Exception):
-    """`<project>/AGENTS.md` symlink provisioning 실패."""
-
-
 def installed_version() -> str:
     """Read the version stamp written by `okstra install` to `~/.okstra/version`.
 
@@ -209,181 +195,3 @@ def _backup_and_replace(target: Path, template: Path) -> None:
         raise SettingsLinkError(
             f"failed to create symlink {target} -> {template} after backup: {exc}"
         ) from exc
-
-
-def installed_claude_md_template_path() -> Path:
-    """okstra install 이 만들어 둔 okstra.CLAUDE.md template 의 절대경로."""
-    return _okstra_home() / "templates" / "okstra.CLAUDE.md"
-
-
-_CLAUDE_MD_SYMLINK_REL = CLAUDE_MD_SYMLINK_RELATIVE
-_CLAUDE_MD_IMPORT_LINE = CLAUDE_MD_IMPORT_LINE
-_CLAUDE_MD_MARKER_BEGIN = (
-    "<!-- okstra:claude-md:begin (managed by okstra setup — do not edit) -->"
-)
-_CLAUDE_MD_MARKER_END = "<!-- okstra:claude-md:end -->"
-
-
-def ensure_project_claude_md(*, project_root: Path) -> Optional[Path]:
-    """okstra-relative `CLAUDE.md` 를 `~/.okstra/templates/okstra.CLAUDE.md`
-    로 가리키는 symlink 로 provisioning 하고, `<project_root>/CLAUDE.md` 에
-    import block 을 멱등하게 주입한다.
-
-    Claude Code 가 해당 프로젝트에서 host 세션으로 실행될 때
-    `<project_root>/CLAUDE.md` 가 자동 로드되므로, okstra 가 관리하는 본문
-    (slash command catalog, workflow guidance, ...) 도 같이 surface 된다.
-
-    반환값:
-      - symlink Path: 신규 생성됐거나 이미 올바른 target 을 가리키고 있을 때.
-      - None: install 이 아직 CLAUDE.md template 을 깔지 않았을 때 (구버전
-        okstra install). 상위에서 경고로 흘려보낸다.
-
-    상위 호출자는 `ClaudeMdLinkError` 만 처리하면 된다.
-    """
-    project_root = Path(project_root)
-    template = installed_claude_md_template_path()
-    if not template.exists():
-        return None
-
-    target = project_root / _CLAUDE_MD_SYMLINK_REL
-    target.parent.mkdir(parents=True, exist_ok=True)
-
-    if target.is_symlink():
-        try:
-            current = os.readlink(target)
-        except OSError as exc:
-            raise ClaudeMdLinkError(
-                f"failed to read existing symlink {target}: {exc}"
-            ) from exc
-        current_path = Path(current)
-        if current_path == template or (target.parent / current_path).resolve() == template.resolve():
-            _ensure_claude_md_import(project_root)
-            return target
-        _backup_and_replace_claude_md(target, template)
-        _ensure_claude_md_import(project_root)
-        return target
-
-    if target.exists():
-        _backup_and_replace_claude_md(target, template)
-        _ensure_claude_md_import(project_root)
-        return target
-
-    try:
-        target.symlink_to(template)
-    except OSError as exc:
-        raise ClaudeMdLinkError(
-            f"failed to create symlink {target} -> {template}: {exc}"
-        ) from exc
-    _ensure_claude_md_import(project_root)
-    return target
-
-
-def _ensure_claude_md_import(project_root: Path) -> bool:
-    """`<project_root>/CLAUDE.md` 에 import block 이 없으면 append, 있으면 no-op.
-
-    반환: 새로 주입했을 때 True, 이미 있었을 때 False.
-    """
-    claude_md = project_root / "CLAUDE.md"
-    block = f"{_CLAUDE_MD_MARKER_BEGIN}\n{_CLAUDE_MD_IMPORT_LINE}\n{_CLAUDE_MD_MARKER_END}\n"
-
-    try:
-        existing = claude_md.read_text(encoding="utf-8")
-    except FileNotFoundError:
-        try:
-            claude_md.write_text(block, encoding="utf-8")
-        except OSError as exc:
-            raise ClaudeMdLinkError(
-                f"failed to create {claude_md}: {exc}"
-            ) from exc
-        return True
-    except OSError as exc:
-        raise ClaudeMdLinkError(f"failed to read {claude_md}: {exc}") from exc
-
-    if _CLAUDE_MD_MARKER_BEGIN in existing and _CLAUDE_MD_MARKER_END in existing:
-        return False
-
-    separator = _block_separator_for(existing)
-    try:
-        claude_md.write_text(existing + separator + block, encoding="utf-8")
-    except OSError as exc:
-        raise ClaudeMdLinkError(f"failed to update {claude_md}: {exc}") from exc
-    return True
-
-
-def _block_separator_for(existing: str) -> str:
-    """기존 파일 끝과 import block 사이의 공백 결정 — 가독성 보장 목적."""
-    if not existing:
-        return ""
-    if existing.endswith("\n\n"):
-        return ""
-    if existing.endswith("\n"):
-        return "\n"
-    return "\n\n"
-
-
-def _backup_and_replace_claude_md(target: Path, template: Path) -> None:
-    """기존 파일/심볼릭링크를 timestamped backup 으로 옮기고 새 symlink 생성."""
-    stamp = time.strftime("%Y%m%d-%H%M%S")
-    backup = target.with_name(f"{target.name}.bak.{stamp}")
-    try:
-        target.rename(backup)
-    except OSError as exc:
-        raise ClaudeMdLinkError(
-            f"failed to back up existing {target} to {backup}: {exc}"
-        ) from exc
-    try:
-        target.symlink_to(template)
-    except OSError as exc:
-        raise ClaudeMdLinkError(
-            f"failed to create symlink {target} -> {template} after backup: {exc}"
-        ) from exc
-
-
-def ensure_project_agents_md(*, project_root: Path) -> Optional[Path]:
-    """`<project_root>/AGENTS.md` 가 없을 때만 `~/.okstra/templates/okstra.CLAUDE.md`
-    로의 심링크로 생성한다.
-
-    AGENTS.md 는 codex / aider / 기타 agent 가 읽는 파일이고 @import 같은
-    부분 포함 메커니즘이 없어, 파일 전체 내용이 곧 agent 가 보는 콘텐츠가
-    된다. 그래서 CLAUDE.md (`@.okstra/CLAUDE.md` 마커 블록
-    주입) 와 달리 "AGENTS.md 가 비어 있을 때만 만들고, 존재하면 절대
-    건드리지 않는" 정책을 사용한다 — 사용자가 직접 작성한 AGENTS.md 를
-    덮어쓰지 않는다.
-
-    반환값:
-      - target Path: 신규 심링크 생성, 또는 이미 우리 템플릿을 가리키고
-        있던 심링크가 idempotent 하게 확인된 경우.
-      - None: install 이 아직 CLAUDE.md template 을 깔지 않았거나,
-        AGENTS.md 가 이미 사용자 콘텐츠 (regular file) 거나 우리가
-        만들지 않은 다른 심링크로 존재하는 경우. 후자 두 케이스는
-        사용자의 의도로 간주하고 건드리지 않는다.
-
-    상위 호출자는 `AgentsMdLinkError` 만 처리하면 된다.
-    """
-    project_root = Path(project_root)
-    template = installed_claude_md_template_path()
-    if not template.exists():
-        return None
-
-    target = project_root / "AGENTS.md"
-
-    if target.is_symlink():
-        try:
-            current = os.readlink(target)
-        except OSError:
-            return None
-        current_path = Path(current)
-        if current_path == template or (target.parent / current_path).resolve() == template.resolve():
-            return target
-        return None  # foreign symlink — respect user
-
-    if target.exists():
-        return None  # regular file — respect user content
-
-    try:
-        target.symlink_to(template)
-    except OSError as exc:
-        raise AgentsMdLinkError(
-            f"failed to create symlink {target} -> {template}: {exc}"
-        ) from exc
-    return target

package/runtime/python/okstra_ctl/wizard.py

@@ -31,6 +31,7 @@ from okstra_ctl.models import (
     UnknownModelError,
     resolve_model_metadata,
 )
+from okstra_ctl.clarification_items import unresolved_approval_blockers
 from okstra_ctl.pr_template import PrTemplateError, resolve_pr_template_path
 from okstra_ctl.run import (
     APPROVED_FRONTMATTER_PATTERN,
@@ -45,6 +46,7 @@ from okstra_ctl.workers import (
     validate_workers_against_profile,
 )
 from okstra_ctl import worktree_registry
+from okstra_ctl.worktree import preview_worktree_decision
 from okstra_project.dirs import project_json_path, tasks_root
 from okstra_project.state import (
     StateError,
@@ -196,6 +198,7 @@ S_CLARIFICATION = "clarification"
 S_PR_TEMPLATE_PICK = "pr_template_pick"
 S_PR_TEMPLATE = "pr_template"
 S_PR_TEMPLATE_SCOPE = "pr_template_scope"
+S_BRANCH_CONFIRM = "branch_confirm"
 S_CONFIRM = "confirm"
 S_EDIT_TARGET = "edit_target"
 S_DONE = "done"
@@ -267,6 +270,7 @@ class WizardState:
     last_pr_template_cached: str = ""
 
     # confirm / edit
+    branch_confirmed: Optional[bool] = None
     confirmed: Optional[bool] = None
     edit_target: str = ""
 
@@ -365,6 +369,18 @@ def _validate_approved_plan(path_str: str, project_root: Path) -> Path:
             "  edit the report and change the line to `approved: true`, or re-run "
             "okstra with `--approve` to flip it from the CLI."
         )
+    # frontmatter approved == true 라도 §5 의 Blocks=approval 행이 미해결이면
+    # 승인이 무효 — prepare_task_bundle 의 _validate_approved_plan 과 동일 규약.
+    blockers = unresolved_approval_blockers(body)
+    if blockers:
+        lines = [
+            f"approved plan frontmatter has `approved: true` but §5 has {len(blockers)} "
+            f"unresolved `Blocks=approval` row(s); resolve them or mark them obsolete first:",
+        ]
+        for b in blockers:
+            lines.append(f"  - {b.row_id} (Status={b.raw_status})")
+        lines.append(f"  file: {p}")
+        raise WizardError("\n".join(lines))
     return p
 
 
@@ -1160,10 +1176,12 @@ def _build_stage_pick(state: WizardState) -> Prompt:
         / "validate-implementation-plan-stages.py"
     )
     spec = _ilu.spec_from_file_location("_ip_stage_v_wizard", str(validator_path))
-    mod = _ilu.module_from_spec(spec)  # type: ignore[arg-type]
+    if spec is None or spec.loader is None:
+        raise WizardError(f"cannot load stage validator at {validator_path}")
+    mod = _ilu.module_from_spec(spec)
     _sys.modules["_ip_stage_v_wizard"] = mod
     try:
-        spec.loader.exec_module(mod)  # type: ignore[union-attr]
+        spec.loader.exec_module(mod)
         stages, _errs = mod._parse_stage_map(plan_text)
     finally:
         _sys.modules.pop("_ip_stage_v_wizard", None)
@@ -1698,6 +1716,49 @@ def _submit_pr_template_scope(state: WizardState, value: str) -> Optional[str]:
     return f"pr-template-scope: {value}"
 
 
+def _build_branch_confirm(state: WizardState) -> Prompt:
+    decision = preview_worktree_decision(
+        project_root=Path(state.project_root),
+        project_id=state.project_id,
+        task_group_segment=state.task_group,
+        task_id_segment=state.task_id,
+        # okstra-run 경로는 --work-category 를 넘기지 않으므로 provision 도 ""(→ "task-" prefix)로
+        # 브랜치를 만든다. 이 단계에서 미리보기 브랜치명은 실제 생성 브랜치와 정확히 일치한다.
+        work_category="",
+        base_ref=state.base_ref,
+    )
+    key = {
+        "new": "new", "reused": "reuse",
+        "skipped-in-worktree": "in_worktree", "skipped-not-git": "not_git",
+    }[decision.status]
+    # Fetch raw step data first so we can compute the label before calling _p.
+    raw = _load_wizard_root(state.workspace_root)["steps"]["branch_confirm"]
+    label = raw["labels"][key].format(
+        branch=decision.branch or "(none)",
+        base_ref=decision.base_ref or "(HEAD)",
+        path=decision.path,
+    )
+    # Pass the computed label as `summary` so _p's placeholder interpolation works.
+    t = _p(state.workspace_root, "branch_confirm", summary=label)
+    opts = t["options"]
+    options = [_opt("proceed", opts["proceed"])]
+    if decision.status == "new":
+        options.append(_opt("edit", opts["edit"]))
+    return Prompt(step=S_BRANCH_CONFIRM, kind="pick", label=label,
+                  options=options, echo_template=t["echo_template"])
+
+
+def _submit_branch_confirm(state: WizardState, value: str) -> Optional[str]:
+    if value == "edit":
+        _reset_from(state, S_BASE_REF_PICK)
+        state.branch_confirmed = None
+        return "branch-confirm: edit"
+    if value != "proceed":
+        raise WizardError(f"expected 'proceed' or 'edit', got: {value!r}")
+    state.branch_confirmed = True
+    return "branch-confirm: proceed"
+
+
 def _build_confirm(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "confirm")
     return Prompt(
@@ -1720,7 +1781,7 @@ def _build_edit_target(state: WizardState) -> Prompt:
     # offer every step that has been answered.
     options: list[Option] = []
     for sid in state.answered:
-        if sid in (S_CONFIRM, S_EDIT_TARGET):
+        if sid in (S_BRANCH_CONFIRM, S_CONFIRM, S_EDIT_TARGET):
             continue
         options.append(_opt(sid, sid))
     return Prompt(
@@ -1976,8 +2037,12 @@ STEPS: list[Step] = [
                             and S_PR_TEMPLATE_SCOPE not in s.answered),
          build=_build_pr_template_scope, submit=_submit_pr_template_scope,
          owns=("pr_template_scope",)),
+    Step(S_BRANCH_CONFIRM,
+         applies=lambda s: _ready_for_confirm(s) and s.branch_confirmed is None,
+         build=_build_branch_confirm, submit=_submit_branch_confirm,
+         owns=("branch_confirmed",)),
     Step(S_CONFIRM,
-         applies=lambda s: _ready_for_confirm(s) and s.confirmed is None,
+         applies=lambda s: _ready_for_confirm(s) and s.branch_confirmed is True and s.confirmed is None,
          build=_build_confirm, submit=_submit_confirm,
          owns=("confirmed", "edit_target")),
     Step(S_EDIT_TARGET,
@@ -2062,7 +2127,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "clarification_response_path": "", "clarification_pending_text": False,
     "pr_template_path": "", "pr_template_pending_text": False,
     "pr_template_scope": "",
-    "confirmed": None, "edit_target": "",
+    "branch_confirmed": None, "confirmed": None, "edit_target": "",
 }
 
 

package/runtime/python/okstra_ctl/work_categories.py

@@ -0,0 +1,21 @@
+"""requirements-discovery work-category(domain) SSOT.
+
+profile / validators / wizard 는 이 모듈에서 enum 을 import 해야 한다. 다른 곳에서
+재정의하면 single-reference-point 위반이며 tests/test_work_categories.py 가 거부한다.
+
+다섯째 값은 `ops` 가 canonical 이다(`--work-category` CLI help 및 workflow.PHASE_RULES
+와 일치). 구버전 비표준 철자는 폐기된다.
+"""
+from __future__ import annotations
+
+WORK_CATEGORIES: tuple[str, ...] = (
+    "bugfix",
+    "feature",
+    "refactor",
+    "ops",
+    "improvement",
+)
+
+
+def is_valid_category(value: str) -> bool:
+    return value in WORK_CATEGORIES

package/runtime/python/okstra_ctl/worktree.py

@@ -46,11 +46,7 @@ from okstra_project.dirs import project_json_path
 from .ids import _safe_fs_segment
 from . import worktree_registry
 from .seeding import (
-    AgentsMdLinkError,
-    ClaudeMdLinkError,
     SettingsLinkError,
-    ensure_project_agents_md,
-    ensure_project_claude_md,
     ensure_project_settings_symlink,
 )
 
@@ -145,6 +141,60 @@ class WorktreeProvision:
     note: str = ""          # human-readable explanation, surfaced in team-state / manifests
 
 
+@dataclass
+class WorktreeDecision:
+    """Side-effect-free preview of what `provision_task_worktree` would do.
+
+    status:
+      - "new": no active registry entry; a fresh worktree would be created
+      - "reused": registry already has this task-key; existing path/branch returned
+      - "skipped-in-worktree": project_root is itself a non-main worktree
+      - "skipped-not-git": project_root has no .git
+    """
+    status: str
+    path: str              # worktree path (new: prospective; reuse: existing; skip: project_root)
+    branch: str = ""       # new: prospective branch; reused: existing branch
+    base_ref: str = ""     # new: requested base_ref; reused: existing base
+
+
+def preview_worktree_decision(
+    *,
+    project_root,
+    project_id: str,
+    task_group_segment: str,
+    task_id_segment: str,
+    work_category: str,
+    base_ref: str = "",
+) -> "WorktreeDecision":
+    """Side-effect-free: what provision_task_worktree WOULD do, without touching disk.
+
+    Mirrors provision's decision branches exactly; reuses the same read-only
+    helpers so preview never diverges from the actual provisioning result.
+    """
+    project_root = Path(project_root)
+    if not _is_git_repo(project_root):
+        return WorktreeDecision(status="skipped-not-git", path=str(project_root))
+    if _is_inside_non_main_worktree(project_root):
+        return WorktreeDecision(status="skipped-in-worktree", path=str(project_root))
+    safe_project = _safe_segment(project_id)
+    safe_group = _safe_segment(task_group_segment)
+    safe_task = _safe_segment(task_id_segment)
+    existing = worktree_registry.lookup(safe_project, safe_group, safe_task)
+    if existing is not None and existing.status == "active":
+        return WorktreeDecision(
+            status="reused", path=existing.worktree_path,
+            branch=existing.branch, base_ref=existing.base_ref,
+        )
+    return WorktreeDecision(
+        status="new",
+        path=str(compute_worktree_path(
+            project_id=safe_project, task_group_segment=safe_group,
+            task_id_segment=safe_task)),
+        branch=compute_branch_name(work_category=work_category, task_id_segment=safe_task),
+        base_ref=base_ref,
+    )
+
+
 def _safe_segment(value: str) -> str:
     """Sanitise a single path/branch segment.
 
@@ -256,11 +306,6 @@ def _read_project_json_field(project_root: Path, field: str) -> Optional[tuple[s
     return cleaned
 
 
-def _read_project_json_sync_dirs(project_root: Path) -> Optional[tuple[str, ...]]:
-    """Back-compat shim — preserves the old name used by external callers."""
-    return _read_project_json_field(project_root, "worktreeSyncDirs")
-
-
 def _resolve_entries(
     *,
     env_var: str,
@@ -399,48 +444,6 @@ def _seed_worktree_settings_symlink(worktree_path: Path) -> None:
         )
 
 
-def _seed_worktree_claude_md(worktree_path: Path) -> None:
-    """Seed `.okstra/CLAUDE.md` symlink + `<worktree>/CLAUDE.md`
-    import block in the worker worktree so dispatched Claude sessions auto-load
-    okstra's runtime guidance. Mirrors `_seed_worktree_settings_symlink` —
-    needed because the worktree's `CLAUDE.md` comes from the git checkout (no
-    marker block unless committed) and `.project-docs/` is only dir-symlinked,
-    not its contents.
-    """
-    try:
-        link = ensure_project_claude_md(project_root=worktree_path)
-    except ClaudeMdLinkError as exc:
-        print(
-            f"okstra-claude-md: failed to seed worker worktree CLAUDE.md at "
-            f"{worktree_path} — dispatched Claude sessions will not auto-load "
-            f"okstra guidance. ({exc})",
-            file=__import__("sys").stderr,
-        )
-        return
-    if link is None:
-        print(
-            "okstra-claude-md: ~/.okstra/templates/okstra.CLAUDE.md missing — "
-            "re-run 'npx okstra@latest install' to provision the symlink target.",
-            file=__import__("sys").stderr,
-        )
-
-
-def _seed_worktree_agents_md(worktree_path: Path) -> None:
-    """Seed `<worktree>/AGENTS.md` symlink so codex / aider sessions dispatched
-    into this worktree auto-load okstra's guidance. Only acts when AGENTS.md
-    is absent — never overwrites user content.
-    """
-    try:
-        ensure_project_agents_md(project_root=worktree_path)
-    except AgentsMdLinkError as exc:
-        print(
-            f"okstra-agents-md: failed to seed worker worktree AGENTS.md at "
-            f"{worktree_path} — dispatched codex / aider sessions will not "
-            f"auto-load okstra guidance. ({exc})",
-            file=__import__("sys").stderr,
-        )
-
-
 def _copy_snapshot_files(source_root: Path, worktree_path: Path) -> list[str]:
     """Copy fixture files from MAIN → task worktree as read-only snapshots
     (FU-V3).
@@ -537,20 +540,26 @@ def provision_task_worktree(
         (`run.py`) catches and re-raises as PrepareError to keep a
         single error surface.
     """
-    if not _is_git_repo(project_root):
+    decision = preview_worktree_decision(
+        project_root=project_root, project_id=project_id,
+        task_group_segment=task_group_segment, task_id_segment=task_id_segment,
+        work_category=work_category, base_ref=base_ref,
+    )
+
+    if decision.status == "skipped-not-git":
         return WorktreeProvision(
             status="skipped-not-git",
-            path=str(project_root),
+            path=decision.path,
             note=(
                 "worktree provisioning skipped: project_root is not inside a git "
                 "repository; task will operate directly on project_root"
             ),
         )
 
-    if _is_inside_non_main_worktree(project_root):
+    if decision.status == "skipped-in-worktree":
         return WorktreeProvision(
             status="skipped-in-worktree",
-            path=str(project_root),
+            path=decision.path,
             note=(
                 "worktree provisioning skipped: project_root is already inside a "
                 "non-main git worktree; task reuses the caller's worktree"
@@ -561,33 +570,23 @@ def provision_task_worktree(
     safe_group = _safe_segment(task_group_segment)
     safe_task = _safe_segment(task_id_segment)
 
-    # Registry lookup first — same task-key across phases must reuse.
-    existing = worktree_registry.lookup(safe_project, safe_group, safe_task)
-    if existing is not None and existing.status == "active":
+    if decision.status == "reused":
         worktree_registry.touch_phase(safe_project, safe_group, safe_task, task_type)
-        _seed_worktree_settings_symlink(Path(existing.worktree_path))
-        _seed_worktree_claude_md(Path(existing.worktree_path))
-        _seed_worktree_agents_md(Path(existing.worktree_path))
+        _seed_worktree_settings_symlink(Path(decision.path))
         return WorktreeProvision(
             status="reused",
-            path=existing.worktree_path,
-            branch=existing.branch,
-            base_ref=existing.base_ref,
+            path=decision.path,
+            branch=decision.branch,
+            base_ref=decision.base_ref,
             note=(
-                f"task worktree reused at {existing.worktree_path} on branch "
-                f"{existing.branch} (base {existing.base_ref[:12]}); phase {task_type}"
+                f"task worktree reused at {decision.path} on branch "
+                f"{decision.branch} (base {decision.base_ref[:12]}); phase {task_type}"
             ),
         )
 
-    worktree_path = compute_worktree_path(
-        project_id=safe_project,
-        task_group_segment=safe_group,
-        task_id_segment=safe_task,
-    )
-    branch = compute_branch_name(
-        work_category=work_category,
-        task_id_segment=safe_task,
-    )
+    # decision.status == "new" — proceed with creation
+    worktree_path = Path(decision.path)
+    branch = decision.branch
 
     if worktree_path.exists():
         raise RuntimeError(
@@ -670,8 +669,6 @@ def provision_task_worktree(
         raise
 
     _seed_worktree_settings_symlink(worktree_path)
-    _seed_worktree_claude_md(worktree_path)
-    _seed_worktree_agents_md(worktree_path)
 
     base_label = (
         f"{base_origin} @ {resolved_base_ref[:12]}"

package/runtime/python/okstra_project/__init__.py

@@ -9,8 +9,6 @@ PROJECT_ROOT 를 해석하고, 실행 시점에 upsert 한다. 과거 모델
 from __future__ import annotations
 
 from .dirs import (
-    CLAUDE_MD_IMPORT_LINE,
-    CLAUDE_MD_SYMLINK_RELATIVE,
     DISCOVERY_RELATIVE,
     LATEST_TASK_RELATIVE,
     OKSTRA_DIR_NAME,
@@ -18,7 +16,6 @@ from .dirs import (
     PROJECT_JSON_RELATIVE,
     TASK_CATALOG_RELATIVE,
     TASKS_RELATIVE,
-    claude_md_symlink_path,
     discovery_dir,
     okstra_root,
     project_json_path,
@@ -42,8 +39,6 @@ from .state import (
 )
 
 __all__ = [
-    "CLAUDE_MD_IMPORT_LINE",
-    "CLAUDE_MD_SYMLINK_RELATIVE",
     "DISCOVERY_RELATIVE",
     "LATEST_TASK_RELATIVE",
     "OKSTRA_DIR_NAME",
@@ -53,7 +48,6 @@ __all__ = [
     "StateError",
     "TASKS_RELATIVE",
     "TASK_CATALOG_RELATIVE",
-    "claude_md_symlink_path",
     "discovery_dir",
     "find_task_root",
     "list_project_tasks",

package/runtime/python/okstra_project/dirs.py

@@ -37,9 +37,6 @@ TASKS_RELATIVE = OKSTRA_RELATIVE / "tasks"
 DISCOVERY_RELATIVE = OKSTRA_RELATIVE / "discovery"
 TASK_CATALOG_RELATIVE = DISCOVERY_RELATIVE / "task-catalog.json"
 LATEST_TASK_RELATIVE = DISCOVERY_RELATIVE / "latest-task.json"
-CLAUDE_MD_SYMLINK_RELATIVE = OKSTRA_RELATIVE / "CLAUDE.md"
-CLAUDE_MD_IMPORT_LINE = f"@{OKSTRA_DIR_NAME}/CLAUDE.md"
-LEGACY_CLAUDE_MD_IMPORT_LINE = f"@{LEGACY_OKSTRA_DIR_NAME}/CLAUDE.md"
 
 
 def okstra_root(project_root: Path) -> Path:
@@ -60,8 +57,3 @@ def tasks_root(project_root: Path) -> Path:
 def discovery_dir(project_root: Path) -> Path:
     """`<project_root>/.okstra/discovery` 절대 path."""
     return Path(project_root) / DISCOVERY_RELATIVE
-
-
-def claude_md_symlink_path(project_root: Path) -> Path:
-    """`<project_root>/.okstra/CLAUDE.md` 절대 path."""
-    return Path(project_root) / CLAUDE_MD_SYMLINK_RELATIVE