context-rail 0.2.0__tar.gz → 0.2.2__tar.gz

{context_rail-0.2.0/src/context_rail.egg-info → context_rail-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: context-rail
-Version: 0.2.0
+Version: 0.2.2
 Summary: Context Rail — agentic task-management that keeps your project on rails.
 License: MIT
 Project-URL: Repository, https://github.com/nguyenhoanhson797/Context-Rail

{context_rail-0.2.0 → context_rail-0.2.2}/pyproject.toml

@@ -1,36 +1,36 @@
-[build-system]
-requires = ["setuptools>=68", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "context-rail"
-version = "0.2.0"
-description = "Context Rail — agentic task-management that keeps your project on rails."
-readme = "README.md"
-license = {text = "MIT"}
-requires-python = ">=3.11"
-dependencies = [
-    "mcp>=1.0.0",
-]
-
-[project.optional-dependencies]
-web = [
-    "context-rail-web",
-]
-test = [
-    "pytest>=8",
-    "pytest-asyncio>=0.24",
-    "fastapi>=0.115",
-]
-
-[project.scripts]
-ctx-rail = "context_rail.cli:main"
-
-[project.urls]
-Repository = "https://github.com/nguyenhoanhson797/Context-Rail"
-
-[tool.setuptools.packages.find]
-where = ["src"]
-
-[tool.setuptools.package-data]
-context_rail = []
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "context-rail"
+version = "0.2.2"
+description = "Context Rail — agentic task-management that keeps your project on rails."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.11"
+dependencies = [
+    "mcp>=1.0.0",
+]
+
+[project.optional-dependencies]
+web = [
+    "context-rail-web",
+]
+test = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+    "fastapi>=0.115",
+]
+
+[project.scripts]
+ctx-rail = "context_rail.cli:main"
+
+[project.urls]
+Repository = "https://github.com/nguyenhoanhson797/Context-Rail"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+context_rail = ["skills/**/*"]

{context_rail-0.2.0 → context_rail-0.2.2}/src/context_rail/server/_tool_surface.py

@@ -24,6 +24,10 @@ CORE_TOOLS = frozenset({
     "task_edit",
     "done",
     "block",
+    # Phase discovery (NCR-1)
+    "phase_tasks",
+    # Contract management (B5/NCR-3)
+    "contract_refresh",
     # Discovery
     "find",
     # Session
@@ -40,6 +44,7 @@ CORE_TOOLS = frozenset({
     # Knowledge capture
     "note",
     "learn",
+    "quick_learn",
     "decision_create",
     # Review
     "retro",

{context_rail-0.2.0 → context_rail-0.2.2}/src/context_rail/server/tools_find.py

@@ -5,12 +5,15 @@ from ._imports import *  # noqa: F403
 
 
 @mcp.tool()
-async def find(query: str, workdir: str = "", agent_id: str = "") -> str:
+async def find(query: str, workdir: str = "", agent_id: str = "", phase_id: str = "") -> str:
     """Search tasks, goals, lessons, notes, risks, and artifacts by keyword.
 
     Searches titles AND descriptions.  Also detects entity-type keywords
     (\"task\", \"goal\", \"phase\", \"roadmap\", etc.) and includes recent items
     of that type even when the keyword doesn't appear in their text.
+
+    Pass phase_id to filter results to tasks and goals in a specific phase.
+    When phase_id is provided without a query, returns all tasks/goals in that phase.
     """
     conn = get_db()
     init_db(conn)
@@ -22,6 +25,16 @@ async def find(query: str, workdir: str = "", agent_id: str = "") -> str:
     q = f"%{query}%"
     q_lower = query.strip().lower()
 
+    # B2 fix: validate phase_id if provided
+    if phase_id:
+        phase = conn.execute(
+            "SELECT id FROM phases WHERE id = ? AND project_id = ? AND deleted_at IS NULL",
+            (phase_id, pid),
+        ).fetchone()
+        if not phase:
+            conn.close()
+            return json.dumps({"error": f"Phase {phase_id} not found in project {pid}"})
+
     # Entity-type keywords: when the user types "task", also list recent tasks
     type_keywords = {
         "task": ("tasks", "SELECT id, title, status, priority, goal_id, assignee FROM tasks WHERE project_id = ? AND deleted_at IS NULL ORDER BY priority DESC LIMIT 10"),
@@ -36,16 +49,32 @@ async def find(query: str, workdir: str = "", agent_id: str = "") -> str:
     }
 
     # --- Tasks ---
-    tasks = conn.execute("""SELECT id, title, status, priority, goal_id, assignee, description
-           FROM tasks WHERE project_id = ? AND (title LIKE ? OR description LIKE ? OR assignee LIKE ?) AND deleted_at IS NULL ORDER BY priority DESC LIMIT 20""",
-        (pid, q, q, q),
-    ).fetchall()
+    if phase_id:
+        tasks = conn.execute("""SELECT id, title, status, priority, goal_id, assignee, description
+               FROM tasks WHERE project_id = ? AND phase_id = ?
+               AND (title LIKE ? OR description LIKE ? OR assignee LIKE ? OR ? = '')
+               AND deleted_at IS NULL ORDER BY priority DESC, sort_order ASC LIMIT 50""",
+            (pid, phase_id, q, q, q, query),
+        ).fetchall()
+    else:
+        tasks = conn.execute("""SELECT id, title, status, priority, goal_id, assignee, description
+               FROM tasks WHERE project_id = ? AND (title LIKE ? OR description LIKE ? OR assignee LIKE ?) AND deleted_at IS NULL ORDER BY priority DESC LIMIT 20""",
+            (pid, q, q, q),
+        ).fetchall()
 
     # --- Goals ---
-    goals = conn.execute("""SELECT id, title, status, priority, description
-           FROM goals WHERE project_id = ? AND (title LIKE ? OR description LIKE ?) AND deleted_at IS NULL ORDER BY priority DESC LIMIT 10""",
-        (pid, q, q),
-    ).fetchall()
+    if phase_id:
+        goals = conn.execute("""SELECT id, title, status, priority, description
+               FROM goals WHERE project_id = ? AND phase_id = ?
+               AND (title LIKE ? OR description LIKE ? OR ? = '')
+               AND deleted_at IS NULL ORDER BY priority DESC LIMIT 10""",
+            (pid, phase_id, q, q, query),
+        ).fetchall()
+    else:
+        goals = conn.execute("""SELECT id, title, status, priority, description
+               FROM goals WHERE project_id = ? AND (title LIKE ? OR description LIKE ?) AND deleted_at IS NULL ORDER BY priority DESC LIMIT 10""",
+            (pid, q, q),
+        ).fetchall()
 
     # --- Entity-type fallback: include recent items of the requested type ---
     entity_fallbacks: dict[str, list] = {}
@@ -138,6 +167,15 @@ async def find(query: str, workdir: str = "", agent_id: str = "") -> str:
             else:
                 result["_note"] = f"Also showing recent {key} (entity-type match)."
 
+    # B2 fix: annotate result when filtered by phase
+    if phase_id:
+        phase_name = conn.execute(
+            "SELECT name FROM phases WHERE id = ?", (phase_id,)
+        ).fetchone()
+        result["_phase_id"] = phase_id
+        if phase_name:
+            result["_phase_name"] = phase_name["name"]
+
     conn.close()
     return json.dumps(result, indent=2)
 

{context_rail-0.2.0 → context_rail-0.2.2}/src/context_rail/server/tools_lifecycle.py

@@ -109,6 +109,29 @@ async def session_start(agent_id: str = "", workdir: str = "") -> str:
                 "progress": rd.get("progress", 0),
             }
 
+    # --- NCR-2: include all phase tasks (compact) for discovery ---
+    result["phase_tasks"] = []
+    if active_phase:
+        phase_tasks = conn.execute(
+            """SELECT id, title, status, priority, lane, goal_id, sort_order, blocked_reason
+               FROM tasks
+               WHERE project_id = ? AND phase_id = ? AND deleted_at IS NULL
+               ORDER BY sort_order ASC, priority DESC""",
+            (pid, active_phase["id"]),
+        ).fetchall()
+        result["phase_tasks"] = [
+            {
+                "id": t["id"],
+                "title": t["title"],
+                "status": t["status"],
+                "priority": t["priority"],
+                "lane": t["lane"] or "normal",
+                "sort_order": t["sort_order"],
+                "blocked_reason": t["blocked_reason"],
+            }
+            for t in phase_tasks
+        ]
+
     # --- Next task ---
     next_task = find_next_task(conn, pid)
     if next_task and not next_task.get("_no_available_task"):

{context_rail-0.2.0 → context_rail-0.2.2}/src/context_rail/server/tools_notes.py

@@ -100,6 +100,99 @@ async def note(content: str, kind: str = "note", task_id: str = "", workdir: str
     return f"Project note saved ({kind}). Use find(\"{title[:30]}\") to search."
 
 
+@mcp.tool()
+async def quick_learn(
+    content: str,
+    kind: str = "",
+    task_id: str = "",
+    workdir: str = "",
+    agent_id: str = "",
+) -> str:
+    """One-param capture with auto-inference. Same friction as memory.add().
+
+    Auto-infers:
+    - task_id from active task (if not provided)
+    - kind from content patterns ("bug" if contains 'bug', 'fix'/'fixed', etc.)
+    - scope (task-scoped when task_id is available, project-scoped otherwise)
+
+    Saves as both a lesson and a note — same content, dual persistence.
+    Use this for quick bug findings, fixes, and observations during execution.
+    """
+    conn = get_db()
+    init_db(conn)
+
+    # Auto-infer task_id
+    if not task_id:
+        task_id = load_state().get("active_task_id", "")
+
+    # Auto-infer kind
+    if not kind:
+        content_lower = content.lower()
+        if any(w in content_lower for w in ("bug", "crash", "error", "null", "undefined", "typeerror", "traceback", "fails")):
+            kind = "pitfall"
+        elif any(w in content_lower for w in ("fixed", "fix", "resolved", "patch", "workaround")):
+            kind = "pattern"
+        else:
+            kind = "decision"
+
+    # Save as lesson (auto-links to task)
+    pid = resolve_pid_for_tool(workdir, agent_id) or load_state().get("active_project_id", "")
+    if not pid:
+        conn.close()
+        return "No active project. Call project_login or project_set_active first."
+
+    tag_list = ["quick_learn"]
+    lid = str(uuid.uuid4())
+
+    # Resolve FK fields from task
+    gid = None
+    phase_id = None
+    if task_id:
+        task = conn.execute(
+            "SELECT goal_id, phase_id FROM tasks WHERE id = ? AND deleted_at IS NULL",
+            (task_id,),
+        ).fetchone()
+        if task:
+            gid = task["goal_id"]
+            phase_id = task["phase_id"]
+
+    conn.execute(
+        """INSERT INTO lessons (id, project_id, goal_id, phase_id, task_id, content, kind, tags, last_verified_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))""",
+        (lid, pid, gid, phase_id, task_id, content, kind, json.dumps(tag_list)),
+    )
+    log_activity(conn, "lesson", lid, "created", {"kind": kind, "content": content[:100], "_via": "quick_learn"})
+
+    # Also save as note on the task (dual persistence)
+    nid = ""
+    if task_id:
+        nid = str(uuid.uuid4())
+        conn.execute(
+            "INSERT INTO task_context (id, task_id, content, kind) VALUES (?, ?, ?, ?)",
+            (nid, task_id, content, kind),
+        )
+        log_activity(conn, "task_context", nid, "created",
+                     {"kind": kind, "_via": "quick_learn"})
+
+    conn.commit()
+    conn.close()
+
+    attach_activity_to_active_cycle(
+        pid,
+        task_id=task_id or "",
+        kind="lesson",
+        summary=content,
+        entity_type="lesson",
+        entity_id=lid,
+        metadata={"lesson_kind": kind, "tags": tag_list},
+    )
+
+    msg = f"Quick-learn saved ({kind}): lesson={lid}"
+    if nid:
+        msg += f", note={nid}"
+    return msg
+
+
 @mcp.tool()
 async def learn(
     content: str,

{context_rail-0.2.0 → context_rail-0.2.2}/src/context_rail/server/tools_plan_review.py

@@ -518,3 +518,115 @@ async def plan_contract_view(contract_id: str = "", workdir: str = "") -> str:
             pass  # Never break view on annotation failure
 
     return json.dumps(contract, indent=2)
+
+
+@mcp.tool()
+async def contract_refresh(contract_id: str = "", workdir: str = "") -> str:
+    """Refresh the plan contract snapshot from live project data.
+
+    Re-snapshots the active (or specified) contract with current task titles,
+    statuses, goals, and phases. Eliminates stale-plan confusion from
+    _snapshot_drift by updating the snapshot to match reality.
+
+    Returns the refreshed contract with before/after drift summary.
+    """
+    state = load_state()
+    pid = state.get("active_project_id") if state else resolve_pid_for_tool(workdir)
+    if not pid:
+        pid = resolve_pid_for_tool(workdir)
+    if not pid:
+        return json.dumps({"error": "No active project"})
+
+    contract = active_plan_contract(pid) if not contract_id else None
+    if contract_id:
+        conn = get_db()
+        init_db(conn)
+        try:
+            row = conn.execute(
+                """SELECT * FROM plan_contracts
+                   WHERE id = ? AND project_id = ? AND deleted_at IS NULL""",
+                (contract_id, pid),
+            ).fetchone()
+            if row:
+                from ..autonomy._contracts import _row_contract
+                contract = _row_contract(row)
+        finally:
+            conn.close()
+
+    if not contract:
+        return json.dumps({"error": "No active plan contract found"})
+
+    contract_cid = contract["id"]
+
+    conn = get_db()
+    init_db(conn)
+    try:
+        # Rebuild snapshot from live data
+        phases = conn.execute(
+            """SELECT id, name, sort_order FROM phases
+               WHERE project_id = ? AND deleted_at IS NULL
+               ORDER BY sort_order ASC""",
+            (pid,),
+        ).fetchall()
+
+        goals = conn.execute(
+            """SELECT id, phase_id, title, priority FROM goals
+               WHERE project_id = ? AND deleted_at IS NULL""",
+            (pid,),
+        ).fetchall()
+
+        tasks = conn.execute(
+            """SELECT id, phase_id, goal_id, title, priority, status
+               FROM tasks
+               WHERE project_id = ? AND deleted_at IS NULL""",
+            (pid,),
+        ).fetchall()
+
+        new_snapshot = {
+            "scope": contract.get("plan_snapshot", {}).get("scope", "project"),
+            "level": contract.get("plan_snapshot", {}).get("level", ""),
+            "phases": [{"id": p["id"], "name": p["name"], "sort_order": p["sort_order"]}
+                       for p in phases],
+            "goals": [{"id": g["id"], "phase_id": g["phase_id"], "title": g["title"],
+                       "priority": g["priority"]} for g in goals],
+            "tasks": [{"id": t["id"], "phase_id": t["phase_id"], "goal_id": t["goal_id"],
+                       "title": t["title"], "priority": t["priority"], "status": t["status"]}
+                      for t in tasks],
+        }
+
+        # Compute drift between old and new snapshots
+        old_snapshot = contract.get("plan_snapshot", {})
+        old_titles = {t["id"]: t.get("title") for t in old_snapshot.get("tasks", [])}
+        new_titles = {t["id"]: t["title"] for t in tasks}
+        drift = [
+            {"task_id": tid, "snapshot_title": old_titles[tid], "live_title": new_titles[tid]}
+            for tid in old_titles if tid in new_titles and old_titles[tid] != new_titles[tid]
+        ]
+
+        # Update digest
+        from ..autonomy._contracts import _contract_digest
+        updated_contract = dict(contract)
+        updated_contract["plan_snapshot"] = new_snapshot
+        new_digest = _contract_digest(updated_contract)
+
+        conn.execute(
+            """UPDATE plan_contracts
+               SET plan_snapshot = ?, digest = ?, updated_at = datetime('now')
+               WHERE id = ?""",
+            (json.dumps(new_snapshot, sort_keys=True, separators=(",", ":")),
+             new_digest, contract_cid),
+        )
+        log_activity(conn, "project", pid, "contract_refreshed",
+                     {"contract_id": contract_cid, "resolved_drifts": len(drift)})
+        conn.commit()
+    finally:
+        conn.close()
+
+    return json.dumps({
+        "contract_id": contract_cid,
+        "version": contract.get("version", 1),
+        "refreshed": True,
+        "resolved_drifts": len(drift),
+        "drift_resolved": drift if drift else [],
+        "_note": "Snapshot updated from live data. Call plan_contract_view() to see the refreshed contract.",
+    }, indent=2)

{context_rail-0.2.0 → context_rail-0.2.2}/src/context_rail/server/tools_tasks.py

@@ -222,12 +222,27 @@ def _context_checkpoint(task_id: str) -> dict:
     """Check if the agent touched any context items for this task.
 
     Returns:
-        dict with items_presented, items_verified, items_applied, items_updated,
-        and should_warn (True if items were presented but none were touched).
+        dict with items_presented, items_touched, and should_warn.
+        should_warn is True when items were presented but none were touched,
+        AND no prior checkpoint warning was logged for this task in the last hour.
+        On the second call the warning is always skipped (speed bump, not wall).
     """
     conn = get_db()
     init_db(conn)
     try:
+        # --- B1 fix: check if already warned for this task recently ---
+        prior_warn = conn.execute(
+            """SELECT COUNT(*) as cnt FROM activity_log
+                WHERE entity_type = 'task'
+                  AND entity_id = ?
+                  AND action = 'context_checkpoint_warned'
+                  AND created_at > datetime('now', '-1 hour')""",
+            (task_id,),
+        ).fetchone()
+        if prior_warn and prior_warn["cnt"] > 0:
+            return {"should_warn": False, "items_presented": 0, "items_touched": 0,
+                    "_bypass": "second_call"}
+
         # Count context items visible to this task (same scope resolution as focus)
         task = conn.execute(
             "SELECT t.*, p.roadmap_id FROM tasks t "
@@ -236,8 +251,8 @@ def _context_checkpoint(task_id: str) -> dict:
             (task_id,),
         ).fetchone()
         if not task:
-            return {"should_warn": False, "items_presented": 0, "items_verified": 0,
-                    "items_applied": 0, "items_updated": 0}
+            return {"should_warn": False, "items_presented": 0,
+                    "items_touched": 0}
 
         task_dict = dict(task)
         gid = task_dict.get("goal_id") or ""
@@ -246,26 +261,29 @@ def _context_checkpoint(task_id: str) -> dict:
         rid = task_dict.get("roadmap_id") or ""
         pid = task_dict.get("project_id") or ""
 
-        # Count items that would be presented (exclude expand_mode=never)
+        # D1 fix: only count task-scoped items and required_for_completion items.
+        # Noisy project/phase-scoped reference items are excluded from the gate.
         conditions = ["project_id = ?", "deleted_at IS NULL", "expand_mode != 'never'"]
         params: list = [pid]
 
-        # Build OR condition for scopes: task, goal, phase, category, roadmap, project
-        scope_parts = ["(scope_type = 'task' AND scope_id = ?)"]
+        scope_parts = []
+        # Task-scoped items are always relevant
+        scope_parts.append("(scope_type = 'task' AND scope_id = ?)")
         params.append(task_id)
         if gid:
-            scope_parts.append("(scope_type = 'goal' AND scope_id = ?)")
+            scope_parts.append("(scope_type = 'goal' AND scope_id = ? AND required_for_completion = 1)")
             params.append(gid)
         if phid:
-            scope_parts.append("(scope_type = 'phase' AND scope_id = ?)")
+            scope_parts.append("(scope_type = 'phase' AND scope_id = ? AND required_for_completion = 1)")
             params.append(phid)
         if cid:
-            scope_parts.append("(scope_type = 'category' AND scope_id = ?)")
+            scope_parts.append("(scope_type = 'category' AND scope_id = ? AND required_for_completion = 1)")
             params.append(cid)
         if rid:
-            scope_parts.append("(scope_type = 'roadmap' AND scope_id = ?)")
+            scope_parts.append("(scope_type = 'roadmap' AND scope_id = ? AND required_for_completion = 1)")
             params.append(rid)
-        scope_parts.append("(scope_type = 'project' AND scope_id = ?)")
+        # Project-scoped items only count if required_for_completion
+        scope_parts.append("(scope_type = 'project' AND scope_id = ? AND required_for_completion = 1)")
         params.append(pid)
 
         count_sql = (
@@ -276,8 +294,8 @@ def _context_checkpoint(task_id: str) -> dict:
         items_presented = count_row["cnt"] if count_row else 0
 
         if items_presented == 0:
-            return {"should_warn": False, "items_presented": 0, "items_verified": 0,
-                    "items_applied": 0, "items_updated": 0}
+            return {"should_warn": False, "items_presented": 0,
+                    "items_touched": 0}
 
         # Check recent activity log for context actions on items linked to this task's scope
         # We check: context_verify, context_apply, context_update in the activity log
@@ -294,8 +312,8 @@ def _context_checkpoint(task_id: str) -> dict:
         ctx_ids = [r["id"] for r in ctx_ids_rows]
 
         if not ctx_ids:
-            return {"should_warn": False, "items_presented": 0, "items_verified": 0,
-                    "items_applied": 0, "items_updated": 0}
+            return {"should_warn": False, "items_presented": 0,
+                    "items_touched": 0}
 
         # Check activity log for context actions on these items recently (last 24h)
         # This is more accurate than checking applied_count (which accumulates across tasks)
@@ -351,11 +369,18 @@ async def done(task_id: str) -> str:
     conn.close()
 
     # --- Context checkpoint: soft gate ---
-    # If context items were presented to this task and none were touched
-    # (verified/applied/updated), warn the agent on first done() call.
-    # The second done() call always succeeds — this is a speed bump, not a wall.
+    # B1 fix: On first done() call, items_presented > 0 with no touches triggers a
+    # warning and logs the event. The second done() call finds the log entry and
+    # skips the checkpoint entirely, delivering on the "always succeed" guarantee.
     checkpoint = _context_checkpoint(task_id)
     if checkpoint.get("should_warn"):
+        # Log the warning so the second call can detect and bypass it
+        conn = get_db()
+        init_db(conn)
+        log_activity(conn, "task", task_id, "context_checkpoint_warned",
+                     {"items_presented": checkpoint["items_presented"],
+                      "items_touched": checkpoint["items_touched"]})
+        conn.close()
         return json.dumps({
             "warning": "context_checkpoint",
             "message": (
@@ -937,6 +962,108 @@ async def task_bulk_delete(task_ids: str = "") -> str:
     }, indent=2)
 
 
+# ---------------------------------------------------------------------------
+# NCR-1: Phase tasks endpoint — list all tasks in a phase
+# ---------------------------------------------------------------------------
+
+@mcp.tool()
+async def phase_tasks(
+    phase_id: str = "",
+    workdir: str = "",
+    agent_id: str = "",
+) -> str:
+    """List all tasks in a phase. Returns tasks grouped by goal with status,
+    priority, lane, and dependencies. Use this to discover what needs to be
+    done in a phase without speculative find() calls.
+
+    If phase_id is omitted, returns tasks for the active (first non-completed) phase.
+    """
+    conn = get_db()
+    init_db(conn)
+    pid = resolve_pid_for_tool(workdir, agent_id)
+    if not pid:
+        conn.close()
+        return json.dumps({"error": "No active project"})
+
+    if not phase_id:
+        phase = conn.execute(
+            """SELECT id, name FROM phases
+               WHERE project_id = ? AND status != 'completed' AND deleted_at IS NULL
+               ORDER BY sort_order ASC LIMIT 1""",
+            (pid,),
+        ).fetchone()
+        if not phase:
+            conn.close()
+            return json.dumps({"error": "No active phase found"})
+        phase_id = phase["id"]
+        phase_name = phase["name"]
+    else:
+        phase_row = conn.execute(
+            "SELECT id, name FROM phases WHERE id = ? AND project_id = ? AND deleted_at IS NULL",
+            (phase_id, pid),
+        ).fetchone()
+        if not phase_row:
+            conn.close()
+            return json.dumps({"error": f"Phase {phase_id} not found"})
+        phase_name = phase_row["name"]
+
+    tasks = conn.execute(
+        """SELECT t.id, t.title, t.status, t.priority, t.lane, t.goal_id,
+                  t.parent_task_id, t.assignee, t.blocked_reason, t.planned,
+                  t.sort_order, t.estimated_hours, t.review_required
+           FROM tasks t
+           WHERE t.project_id = ? AND t.phase_id = ? AND t.deleted_at IS NULL
+           ORDER BY t.sort_order ASC, t.priority DESC""",
+        (pid, phase_id),
+    ).fetchall()
+
+    goals = conn.execute(
+        """SELECT g.id, g.title, g.status, g.priority
+           FROM goals g
+           WHERE g.project_id = ? AND g.phase_id = ? AND g.deleted_at IS NULL
+           ORDER BY g.priority DESC""",
+        (pid, phase_id),
+    ).fetchall()
+
+    total = len(tasks)
+    completed = sum(1 for t in tasks if t["status"] == "completed")
+    blocked = sum(1 for t in tasks if t["status"] == "blocked")
+    pending = total - completed - blocked
+
+    # Group tasks by goal
+    goal_map: dict[str, dict] = {g["id"]: {**dict(g), "tasks": []} for g in goals}
+    unlinked: list[dict] = []
+
+    for t in tasks:
+        td = dict(t)
+        gid = td.get("goal_id")
+        if gid and gid in goal_map:
+            goal_map[gid]["tasks"].append(td)
+        else:
+            unlinked.append(td)
+
+    result = {
+        "phase_id": phase_id,
+        "phase_name": phase_name,
+        "summary": {
+            "total": total,
+            "completed": completed,
+            "pending": pending,
+            "blocked": blocked,
+        },
+        "goals": [
+            {"id": gid, "title": g["title"], "status": g["status"],
+             "priority": g["priority"], "task_count": len(g["tasks"]),
+             "tasks": g["tasks"]}
+            for gid, g in goal_map.items() if g["tasks"]
+        ],
+        "unlinked_tasks": unlinked,
+    }
+
+    conn.close()
+    return json.dumps(result, indent=2)
+
+
 # ---------------------------------------------------------------------------
 # Project notes CRUD (update/delete)
 # ---------------------------------------------------------------------------