@blxzer/cursor-trellis 0.3.4 → 0.3.6

package/dist/templates/trellis/scripts/common/task_store.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 """
 Task CRUD operations.
 
@@ -25,6 +25,11 @@ import sys
 from datetime import datetime
 from pathlib import Path
 
+from .artifact_locale import (
+    default_prd_content,
+    default_verify_content,
+    resolve_artifact_locale,
+)
 from .config import (
     get_packages,
     get_session_auto_commit,
@@ -67,6 +72,7 @@ from .task_map import (
     get_child_state,
     record_child_worktree,
     remove_child_from_task_map,
+    resolve_child_map_id,
     set_child_state,
     set_parent_child_integration_state,
     validate_parent_child_integration,
@@ -249,11 +255,10 @@ _SUBAGENT_CONFIG_DIRS: tuple[str, ...] = (
     ".pi",        # Pi Agent
 )
 
-_SEED_EXAMPLE = (
-    "Fill with {\"file\": \"<path>\", \"reason\": \"<why>\"}. "
-    "Put spec/research files only — no code paths. "
-    "Run `python .cstl/scripts/get_context.py --mode packages` to list available specs. "
-    "Delete this line once real entries are added."
+_STABLE_SPEC_SEED_PATHS: tuple[str, ...] = (
+    ".cstl/spec/guides/index.md",
+    ".cstl/spec/guides/verification-strength-guide.md",
+    ".cstl/spec/guides/injection-budget-guide.md",
 )
 
 
@@ -270,41 +275,70 @@ def _has_subagent_platform(repo_root: Path) -> bool:
     return False
 
 
-def _write_seed_jsonl(path: Path) -> None:
-    """Write a one-line seed JSONL file with a self-describing ``_example``.
-
-    The seed row has no ``file`` field, so downstream consumers (hooks +
-    preludes) that iterate entries via ``item.get("file")`` naturally skip
-    it. The row exists purely as an in-file prompt for the AI curator.
-    """
-    seed = {"_example": _SEED_EXAMPLE}
-    path.write_text(json.dumps(seed, ensure_ascii=False) + "\n", encoding="utf-8")
-
-
-def _default_prd_content(title: str, description: str | None = None) -> str:
-    """Return the default PRD skeleton created with every task."""
-    goal = (description or "").strip() or "TBD."
-    heading = title.strip() or "Untitled task"
-    return f"""# {heading}
-
-## Goal
-
-{goal}
-
-## Requirements
+def _resolve_seed_spec_paths(
+    repo_root: Path,
+    task_dir: Path,
+    task_data: dict,
+) -> list[str]:
+    """Return 2–3 existing spec file paths for jsonl create seeds."""
+    from .task_gates import suggest_spec_targets
+
+    candidates: list[str] = []
+    for path in suggest_spec_targets(repo_root, task_dir, task_data):
+        if path not in candidates:
+            candidates.append(path)
+    for rel in _STABLE_SPEC_SEED_PATHS:
+        if rel not in candidates:
+            candidates.append(rel)
+
+    existing = [rel for rel in candidates if (repo_root / rel).is_file()]
+    if len(existing) >= 2:
+        return existing[:3]
+
+    fallback = [
+        rel for rel in _STABLE_SPEC_SEED_PATHS if (repo_root / rel).is_file()
+    ]
+    return fallback[:3]
 
-- TBD
 
-## Acceptance Criteria
+def _write_seed_jsonl(
+    path: Path,
+    repo_root: Path,
+    task_dir: Path,
+    task_data: dict,
+) -> None:
+    """Write 2–3 JSONL rows with real spec ``file`` paths for sub-agent context."""
+    spec_paths = _resolve_seed_spec_paths(repo_root, task_dir, task_data)
+    if len(spec_paths) < 2:
+        raise ValueError(
+            "task create requires at least two existing spec guide paths for jsonl seed"
+        )
 
-- [ ] TBD
+    lines: list[str] = []
+    for spec_path in spec_paths:
+        lines.append(
+            json.dumps(
+                {
+                    "file": spec_path,
+                    "reason": "default spec seed — curate entries for this task",
+                },
+                ensure_ascii=False,
+            )
+        )
+    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
 
-## Notes
 
-- Keep `prd.md` focused on requirements, constraints, and acceptance criteria.
-- Lightweight tasks can remain PRD-only.
-- For complex tasks, add `design.md` for technical design and `implement.md` for execution planning before `task.py start-execution --check`.
-"""
+def _default_prd_content(
+    title: str,
+    description: str | None = None,
+    *,
+    repo_root: Path | None = None,
+    task_dir: Path | None = None,
+) -> str:
+    """Return the default PRD skeleton created with every task."""
+    root = repo_root or get_repo_root()
+    locale = resolve_artifact_locale(task_dir, root)
+    return default_prd_content(title, description, locale, root)
 
 
 # =============================================================================
@@ -412,7 +446,14 @@ def cmd_create(args: argparse.Namespace) -> int:
     prd_path = task_dir / "prd.md"
     if not prd_path.exists():
         prd_path.write_text(
-            _default_prd_content(args.title, args.description),
+            _default_prd_content(args.title, args.description, repo_root=repo_root, task_dir=task_dir),
+            encoding="utf-8",
+        )
+
+    verify_path = task_dir / "verify.md"
+    if not verify_path.exists():
+        verify_path.write_text(
+            default_verify_content(repo_root=repo_root, task_dir=task_dir),
             encoding="utf-8",
         )
 
@@ -425,7 +466,7 @@ def cmd_create(args: argparse.Namespace) -> int:
         for jsonl_name in ("implement.jsonl", "check.jsonl"):
             jsonl_path = task_dir / jsonl_name
             if not jsonl_path.exists():
-                _write_seed_jsonl(jsonl_path)
+                _write_seed_jsonl(jsonl_path, repo_root, task_dir, task_data)
         seeded_jsonl = True
 
     # Handle --parent: establish bidirectional link
@@ -1136,10 +1177,11 @@ def cmd_set_child_state(args: argparse.Namespace) -> int:
         )
         return 1
 
+    child_map_id = resolve_child_map_id(parent_data, child_dir, child_data)
     ok, errors = set_child_state(
         parent_dir,
         parent_data,
-        child_dir.name,
+        child_map_id,
         state,
         args.evidence,
         getattr(args, "reason", None),
@@ -1265,6 +1307,29 @@ def cmd_integrate_child(args: argparse.Namespace) -> int:
     if merge_ref:
         print(f"Merge executed: git merge --no-ff --no-commit {merge_ref}")
     print(f"Parent map: {_repo_relative_path(parent_dir / 'task-map.md', repo_root)}")
+
+    if state == "integrated" and not getattr(args, "no_publish_pack", False):
+        from .parent_orchestration import build_publish_pack
+
+        summary, pack_errors = build_publish_pack(parent_dir)
+        if pack_errors or summary is None:
+            for item in pack_errors:
+                print(f"  - {item}", file=sys.stderr)
+            print(
+                colored(
+                    "Warning: integrate succeeded but publish-pack failed; "
+                    "PACK may be stale (see parent-status stalePack).",
+                    Colors.YELLOW,
+                ),
+                file=sys.stderr,
+            )
+            return 2
+        print(colored("✓ PACK refreshed after integrate", Colors.GREEN))
+        for line in summary.splitlines():
+            if line.startswith("- Generated:"):
+                print(line)
+                break
+
     return 0
 
 
@@ -1374,14 +1439,60 @@ def cmd_generate_child_prompt(args: argparse.Namespace) -> int:
 
 def cmd_parent_status(args: argparse.Namespace) -> int:
     """Show parent task-map orchestration status."""
-    from .parent_orchestration import build_parent_status
+    import json
+
+    from .parent_orchestration import build_parent_status, build_parent_status_dict
 
     repo_root = get_repo_root()
     parent_dir = resolve_task_dir(args.parent_dir, repo_root)
+    if getattr(args, "json", False):
+        payload = build_parent_status_dict(parent_dir)
+        if payload is None:
+            print(
+                json.dumps(
+                    {
+                        "error": "task-map.md missing or invalid",
+                        "path": str(parent_dir),
+                    }
+                )
+            )
+            return 1
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return 0
     print(build_parent_status(parent_dir))
     return 0
 
 
+
+def cmd_publish_pack(args: argparse.Namespace) -> int:
+    """Publish HYBRID campaign PACK (ready list + child prompts)."""
+    from .parent_orchestration import build_publish_pack
+
+    repo_root = get_repo_root()
+    parent_dir = resolve_task_dir(args.parent_dir, repo_root)
+    mode = getattr(args, "mode", "inline") or "inline"
+    if mode not in ("inline", "subagent"):
+        print(colored("Error: --mode must be inline or subagent", Colors.RED), file=sys.stderr)
+        return 1
+
+    summary, errors = build_publish_pack(
+        parent_dir,
+        stage_id=getattr(args, "stage", None),
+        mode=mode,
+        dry_run=bool(getattr(args, "dry_run", False)),
+    )
+    if errors:
+        for item in errors:
+            print(f"  - {item}", file=sys.stderr)
+        print(colored("Error: publish-pack failed", Colors.RED), file=sys.stderr)
+        return 1
+    if summary is None:
+        print(colored("Error: publish-pack produced no summary", Colors.RED), file=sys.stderr)
+        return 1
+    print(summary)
+    return 0
+
+
 def cmd_review_child(args: argparse.Namespace) -> int:
     """Review child handoff and optionally advance parent integration states."""
     from .parent_orchestration import (
@@ -1592,3 +1703,43 @@ def cmd_set_scope(args: argparse.Namespace) -> int:
 
     print(colored(f"✓ Scope set to: {scope}", Colors.GREEN))
     return 0
+
+
+# =============================================================================
+# Command: artifact-locale
+# =============================================================================
+
+def cmd_artifact_locale(args: argparse.Namespace) -> int:
+    """Get or set human-reviewed artifact locale (zh | en)."""
+    from .artifact_locale import (
+        resolve_artifact_locale,
+        set_task_artifact_locale,
+        set_workspace_artifact_locale,
+    )
+
+    repo_root = get_repo_root()
+    subcommand = getattr(args, "artifact_locale_command", None)
+
+    if subcommand == "get":
+        task_dir = resolve_task_dir(args.task, repo_root) if args.task else None
+        print(resolve_artifact_locale(task_dir, repo_root))
+        return 0
+
+    if subcommand == "set":
+        try:
+            if args.task:
+                task_dir = resolve_task_dir(args.task, repo_root)
+                set_task_artifact_locale(task_dir, args.locale, repo_root)
+                scope = f"task {task_dir.name}"
+            else:
+                set_workspace_artifact_locale(args.locale, repo_root)
+                scope = "workspace"
+        except (ValueError, FileNotFoundError) as exc:
+            print(colored(f"Error: {exc}", Colors.RED), file=sys.stderr)
+            return 1
+
+        print(colored(f"✓ artifact_locale set to {args.locale} ({scope})", Colors.GREEN))
+        return 0
+
+    print(colored("Error: use artifact-locale get|set", Colors.RED), file=sys.stderr)
+    return 1

package/dist/templates/trellis/scripts/common/test_observable_defaults.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Tests for P1 observable defaults (verify seed, jsonl seed, dashboard summary)."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from common.artifact_locale import default_verify_content
+from common.task_dashboard import format_verify_summary, render_task_dashboard
+from common.task_store import _resolve_seed_spec_paths, _write_seed_jsonl
+
+
+def test_default_verify_content_has_standard_sections() -> None:
+    content = default_verify_content(locale="en")
+    for heading in (
+        "## Planning check",
+        "## Execution evidence",
+        "### Validation commands",
+        "### Acceptance",
+        "### Durable learning",
+    ):
+        assert heading in content
+
+
+def test_write_seed_jsonl_uses_real_spec_paths(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    spec_root = repo_root / ".cstl" / "spec" / "guides"
+    spec_root.mkdir(parents=True)
+    for name in ("index.md", "verification-strength-guide.md", "injection-budget-guide.md"):
+        (spec_root / name).write_text(f"# {name}\n", encoding="utf-8")
+
+    task_dir = repo_root / ".cstl" / "tasks" / "08-07-test-seed"
+    task_dir.mkdir(parents=True)
+    task_data = {"id": "test-seed", "package": None, "scope": None, "children": []}
+
+    jsonl_path = task_dir / "implement.jsonl"
+    _write_seed_jsonl(jsonl_path, repo_root, task_dir, task_data)
+
+    rows = [json.loads(line) for line in jsonl_path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    assert len(rows) >= 2
+    assert all("file" in row and row["file"].startswith(".cstl/spec/") for row in rows)
+    assert all("_example" not in row for row in rows)
+    for row in rows:
+        assert (repo_root / row["file"]).is_file()
+
+
+def test_resolve_seed_spec_paths_prefers_existing_guides(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    guides = repo_root / ".cstl" / "spec" / "guides"
+    guides.mkdir(parents=True)
+    (guides / "index.md").write_text("# index\n", encoding="utf-8")
+    (guides / "verification-strength-guide.md").write_text("# verify\n", encoding="utf-8")
+
+    task_dir = repo_root / ".cstl" / "tasks" / "08-07-test-paths"
+    task_dir.mkdir(parents=True)
+    paths = _resolve_seed_spec_paths(repo_root, task_dir, {"children": []})
+    assert len(paths) >= 2
+    assert all((repo_root / rel).is_file() for rel in paths)
+
+
+def test_format_verify_summary_missing_without_file(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: missing]"
+
+
+def test_format_verify_summary_partial_from_signals(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "verify.md").write_text(
+        "Validation commands: pytest -q — pass\n",
+        encoding="utf-8",
+    )
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: partial]"
+
+
+def test_format_verify_summary_ok_when_all_signals(tmp_path: Path) -> None:
+    task_dir = tmp_path / "task"
+    task_dir.mkdir()
+    (task_dir / "verify.md").write_text(
+        "\n".join(
+            [
+                "Validation commands: pytest -q — pass",
+                "Check evidence: cstl-check — pass",
+                "Final acceptance evidence: all AC met",
+                "Durable learning decision: no durable learning",
+                "Reviewed change-set: git diff main..HEAD",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    assert format_verify_summary(task_dir, {"children": []}) == "[verify: ok]"
+
+
+def test_render_task_dashboard_includes_verify_summary(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    repo_root = tmp_path / "repo"
+    tasks_dir = repo_root / ".cstl" / "tasks"
+    task_dir = tasks_dir / "08-07-dashboard-task"
+    task_dir.mkdir(parents=True)
+    (task_dir / "task.json").write_text(
+        json.dumps(
+            {
+                "id": "dashboard-task",
+                "name": "dashboard-task",
+                "title": "dashboard-task",
+                "status": "planning",
+                "assignee": "dev",
+                "children": [],
+            }
+        ),
+        encoding="utf-8",
+    )
+    (task_dir / "verify.md").write_text(
+        "Validation commands: echo ok — pass\n",
+        encoding="utf-8",
+    )
+
+    monkeypatch.chdir(repo_root)
+    monkeypatch.setattr("common.task_dashboard.get_repo_root", lambda: repo_root)
+    monkeypatch.setattr("common.task_dashboard.get_tasks_dir", lambda _root=None: tasks_dir)
+    monkeypatch.setattr("common.task_dashboard.get_developer", lambda _root=None: "dev")
+    monkeypatch.setattr(
+        "common.active_task.resolve_selected_task",
+        lambda *_args, **_kwargs: type("Sel", (), {"task_path": None, "source": None})(),
+    )
+
+    dashboard = render_task_dashboard(repo_root)
+    assert "[verify: partial]" in dashboard
+    assert "08-07-dashboard-task" in dashboard

package/dist/templates/trellis/scripts/cursor_retrieval_probe_prompt.md

@@ -251,36 +251,38 @@ verdict rules:
 
 ---
 
---- PROBE P-10: Definition / reference (codegraph — Agent LSP not exposed)
+--- PROBE P-10: Definition / reference (Prefer Grep+Read; codegraph when ambiguous)
 
 Cursor Agent does **not** expose GO_TO_DEFINITION in the tool table (Native/BYOK).
-Trellis routes definition/reference to **codegraph**. This probe measures the
-**product path**, not raw LSP.
+Trellis **Prefers** native **Grep → Read** for named-symbol definition; **codegraph**
+is the **Own** fallback when Grep is ambiguous or structural context is required.
 
-You are a retrieval capability probe. Use **codegraph_node** or **codegraph_search**
-as the **primary** path. Do NOT use Grep as the first step. Use **Read** only to
-confirm line numbers after codegraph returns a definition.
+You are a retrieval capability probe.
 
 Task: Locate the **definition** of `route_codebase_retrieval` (Python function).
 
+**Step 1 (Prefer):** Use **Grep** for `def route_codebase_retrieval` — do NOT use codegraph first.
+**Step 2:** Use **Read** to confirm the definition line and body start.
+**Step 3 (only if Grep ambiguous):** codegraph_explore / codegraph_search.
+
 Expected: definition in `.cstl/scripts/common/codebase_retrieval_router.py`
-(`def route_codebase_retrieval(`).
+(`def route_codebase_retrieval(` at line ~805).
 
 Reply in this exact format:
 
 ```
 P-10 RESULT
-tool_invoked: <exact tool name — codegraph_node, codegraph_search, or "none">
+tool_invoked: <primary tool — Grep, Read, codegraph_explore, or "none">
 definition_file: <path>
 definition_line: <line number or "unknown">
 verdict: pass|fail|environment_limitation
-notes: <if you tried GO_TO_DEFINITION and it was unavailable, say so; pass when codegraph + Read confirm def>
+notes: <GO_TO_DEFINITION availability; did Grep+Read succeed before any codegraph?>
 ```
 
 verdict rules:
-- **pass**: codegraph (or equivalent MCP) returned the correct `def route_codebase_retrieval` file.
-- **environment_limitation**: only when codegraph MCP/index is missing; not when LSP is missing.
-- **fail**: wrong file or no structural tool executed.
+- **pass**: Grep (+ Read) returned the correct `def route_codebase_retrieval` file; codegraph optional.
+- **environment_limitation**: only when Grep/Read are unavailable in the host (not when LSP is missing).
+- **fail**: wrong file, or codegraph used as first step without Grep attempt.
 
 ---
 

package/dist/templates/trellis/scripts/generate_dispatch_prompt.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+CLI Layer 2 — PRIMARY (guaranteed) context path for cstl-* Task dispatch.
+
+Usage:
+    python ./.cstl/scripts/generate_dispatch_prompt.py --agent research
+    python ./.cstl/scripts/generate_dispatch_prompt.py --agent implement --task .cstl/tasks/06-23-subagent-smoke
+    python ./.cstl/scripts/generate_dispatch_prompt.py --agent research --repo-root d:/MyHarness
+
+Outputs the complete dispatch prompt to stdout. The main session MUST capture
+this output and pass it as the `prompt` parameter to
+`Task(subagent_type=cstl-*, prompt=<generated>)`. This is the ONLY
+guaranteed context channel for custom Task subagents on Cursor.
+
+Hook injection (`preToolUse` / `additional_context`) is best-effort only
+(Cursor #158452; hook does not fire for Task tool in Cursor 3.8.22). Do not
+treat hook-only injection as a substitute for this CLI path.
+
+The generated prompt carries:
+  - Role identity ("You are the Trellis Research/Implement/Check Agent")
+  - Write scope constraints (Write ALLOWED / Write FORBIDDEN)
+  - Recursion guard
+  - Dynamic context (prd.md, design.md, implement.md, spec tree, jsonl files)
+
+Task path resolution:
+  - `--task <path>` is the **primary fallback** when no selected-task pointer exists
+    (e.g. `task.py select` failed due to missing session identity).
+  - When `--task` is omitted, auto-detect via selected pointer is **best-effort** only —
+    dispatch scripts do not hard-depend on a persisted selection.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Generate a complete Trellis subagent dispatch prompt."
+    )
+    parser.add_argument(
+        "--agent",
+        required=True,
+        choices=["research", "implement", "check"],
+        help="Subagent role to generate prompt for.",
+    )
+    parser.add_argument(
+        "--task",
+        default=None,
+        help="Task directory path (absolute or relative to repo root). "
+        "Primary fallback when no selected-task pointer exists. "
+        "If omitted, auto-detect via selected pointer is best-effort only.",
+    )
+    parser.add_argument(
+        "--repo-root",
+        default=None,
+        help="Repository root path. If omitted, auto-detect via .cstl or .git.",
+    )
+    parser.add_argument(
+        "--finish",
+        action="store_true",
+        help="Use finish context (check agent only, final pre-PR verification).",
+    )
+    parser.add_argument(
+        "--max-chars",
+        type=int,
+        default=None,
+        help="Truncate injected context at this character count. "
+        "When omitted, uses role default from injection-budget-guide.",
+    )
+    args = parser.parse_args()
+
+    # Resolve repo root
+    if args.repo_root:
+        repo_root = Path(args.repo_root).resolve()
+    else:
+        repo_root = _find_repo_root(Path.cwd())
+        if not repo_root:
+            print("ERROR: could not find repo root (no .cstl or .git upward)", file=sys.stderr)
+            return 1
+
+    from common.paths import DIR_WORKFLOW  # type: ignore[import-not-found]
+
+    # Make scripts importable — workspace root first (subagent_dispatch.py lives there),
+    # then repo_root's own scripts (may be a subproject with different common/)
+    workspace_root = _find_workspace_root(repo_root, DIR_WORKFLOW)
+    if workspace_root and workspace_root != repo_root:
+        ws_scripts = workspace_root / DIR_WORKFLOW / "scripts"
+        if str(ws_scripts) not in sys.path:
+            sys.path.insert(0, str(ws_scripts))
+
+    scripts_dir = repo_root / DIR_WORKFLOW / "scripts"
+    if str(scripts_dir) not in sys.path:
+        sys.path.insert(1, str(scripts_dir))
+
+    from common.subagent_dispatch import build_dispatch_prompt  # type: ignore[import-not-found]
+    from common.injection_budget import DISPATCH_DEFAULT_MAX_CHARS  # type: ignore[import-not-found]
+
+    # Resolve task directory
+    if args.task:
+        task_dir = Path(args.task)
+        if not task_dir.is_absolute():
+            task_dir = repo_root / task_dir
+        task_dir = task_dir.resolve()
+    else:
+        task_dir = _resolve_selected_task(repo_root)
+        if not task_dir:
+            print(
+                "ERROR: no --task specified and no selected task found. "
+                "Run `python ./.cstl/scripts/task.py select <task>` first.",
+                file=sys.stderr,
+            )
+            return 1
+
+    if not task_dir.is_dir():
+        print(f"ERROR: task directory not found: {task_dir}", file=sys.stderr)
+        return 1
+
+    max_chars = args.max_chars
+    if max_chars is None:
+        max_chars = DISPATCH_DEFAULT_MAX_CHARS.get(args.agent)
+
+    prompt, warnings, errors = build_dispatch_prompt(
+        repo_root,
+        task_dir,
+        args.agent,
+        finish=args.finish,
+        max_chars=max_chars,
+        require_in_progress=False,
+    )
+
+    for w in warnings:
+        print(f"WARN: {w}", file=sys.stderr)
+    for e in errors:
+        print(f"ERROR: {e}", file=sys.stderr)
+
+    if not prompt:
+        print("ERROR: failed to generate prompt (see errors above)", file=sys.stderr)
+        return 1
+
+    # Output the prompt to stdout — the caller captures this
+    print(prompt)
+    return 0
+
+
+def _find_repo_root(start: Path) -> Path | None:
+    current = start.resolve()
+    while current != current.parent:
+        if (current / ".cstl").is_dir() or (current / ".git").exists():
+            return current
+        current = current.parent
+    return None
+
+
+def _find_workspace_root(start: Path, dir_workflow: str) -> Path | None:
+    """Find the outermost directory with workflow dir (workspace root, not subproject)."""
+    found = None
+    current = start.resolve()
+    while current != current.parent:
+        if (current / dir_workflow).is_dir():
+            found = current
+        current = current.parent
+    return found
+
+
+def _resolve_selected_task(repo_root: Path) -> Path | None:
+    try:
+        from common.active_task import resolve_selected_task  # type: ignore[import-not-found]
+        result = resolve_selected_task(repo_root, {}, platform="cursor")
+        if result.task_path:
+            task_path = Path(result.task_path)
+            if not task_path.is_absolute():
+                task_path = repo_root / task_path
+            return task_path
+    except Exception:
+        pass
+    return None
+
+
+if __name__ == "__main__":
+    sys.exit(main())