@mindfoldhq/trellis 0.3.5 → 0.3.6

package/dist/templates/qoder/skills/record-session/SKILL.md

@@ -17,7 +17,10 @@ description: "Record work progress after human has tested and committed code"
 python3 ./.trellis/scripts/get_context.py --mode record
 ```
 
-[!] If MY ACTIVE TASKS shows any completed tasks, archive them FIRST:
+[!] Archive tasks whose work is **actually done** — judge by work status, not the `status` field in task.json:
+- Code committed? → Archive it (don't wait for PR)
+- All acceptance criteria met? → Archive it
+- Don't skip archiving just because `status` still says `planning` or `in_progress`
 
 ```bash
 python3 ./.trellis/scripts/task.py archive <task-name>

package/dist/templates/qoder/skills/start/SKILL.md

@@ -73,6 +73,10 @@ When user describes a task, classify it:
 > Task Workflow ensures specs are injected to agents, resulting in higher quality code.
 > The overhead is minimal, but the benefit is significant.
 
+> **Subtask Decomposition**: If a task has multiple independent work items,
+> consider creating subtasks using `--parent` flag or `add-subtask` command.
+> See the brainstorm skill's Step 8 for details.
+
 ---
 
 ## Question / Trivial Fix

package/dist/templates/trellis/config.yaml

@@ -13,3 +13,21 @@ session_commit_message: "chore: record journal"
 
 # Maximum lines per journal file before rotating to a new one
 max_journal_lines: 2000
+
+#-------------------------------------------------------------------------------
+# Task Lifecycle Hooks
+#-------------------------------------------------------------------------------
+
+# Shell commands to run after task lifecycle events.
+# Each hook receives TASK_JSON_PATH environment variable pointing to task.json.
+# Hook failures print a warning but do not block the main operation.
+#
+# hooks:
+#   after_create:
+#     - "echo 'Task created'"
+#   after_start:
+#     - "echo 'Task started'"
+#   after_finish:
+#     - "echo 'Task finished'"
+#   after_archive:
+#     - "echo 'Task archived'"

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

@@ -50,3 +50,23 @@ def get_max_journal_lines(repo_root: Path | None = None) -> int:
         return int(value)
     except (ValueError, TypeError):
         return DEFAULT_MAX_JOURNAL_LINES
+
+
+def get_hooks(event: str, repo_root: Path | None = None) -> list[str]:
+    """Get hook commands for a lifecycle event.
+
+    Args:
+        event: Event name (e.g. "after_create", "after_archive").
+        repo_root: Repository root path.
+
+    Returns:
+        List of shell commands to execute, empty if none configured.
+    """
+    config = _load_config(repo_root)
+    hooks = config.get("hooks")
+    if not isinstance(hooks, dict):
+        return []
+    commands = hooks.get(event)
+    if isinstance(commands, list):
+        return [str(c) for c in commands]
+    return []

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

@@ -11,7 +11,6 @@ Provides:
 from __future__ import annotations
 
 import json
-import sys
 import subprocess
 from pathlib import Path
 
@@ -127,6 +126,8 @@ def get_context_json(repo_root: Path | None = None) -> dict:
                                 "dir": d.name,
                                 "name": data.get("name") or data.get("id") or "unknown",
                                 "status": data.get("status", "unknown"),
+                                "children": data.get("children", []),
+                                "parent": data.get("parent"),
                             }
                         )
 
@@ -263,6 +264,8 @@ def get_context_text(repo_root: Path | None = None) -> str:
     tasks_dir = get_tasks_dir(repo_root)
     task_count = 0
 
+    # Collect all task data for hierarchy display
+    all_task_data: dict[str, dict] = {}
     if tasks_dir.is_dir():
         for d in sorted(tasks_dir.iterdir()):
             if d.is_dir() and d.name != "archive":
@@ -270,15 +273,47 @@ def get_context_text(repo_root: Path | None = None) -> str:
                 t_json = d / FILE_TASK_JSON
                 status = "unknown"
                 assignee = "-"
+                children: list[str] = []
+                parent: str | None = None
 
                 if t_json.is_file():
                     data = _read_json_file(t_json)
                     if data:
                         status = data.get("status", "unknown")
                         assignee = data.get("assignee", "-")
-
-                lines.append(f"- {dir_name}/ ({status}) @{assignee}")
-                task_count += 1
+                        children = data.get("children", [])
+                        parent = data.get("parent")
+
+                all_task_data[dir_name] = {
+                    "status": status,
+                    "assignee": assignee,
+                    "children": children,
+                    "parent": parent,
+                }
+
+    def _children_progress(children_list: list[str]) -> str:
+        if not children_list:
+            return ""
+        done = 0
+        for c in children_list:
+            if c in all_task_data and all_task_data[c]["status"] in ("completed", "done"):
+                done += 1
+        return f" [{done}/{len(children_list)} done]"
+
+    def _print_task_tree(name: str, indent: int = 0) -> None:
+        nonlocal task_count
+        info = all_task_data[name]
+        progress = _children_progress(info["children"]) if info["children"] else ""
+        prefix = "  " * indent
+        lines.append(f"{prefix}- {name}/ ({info['status']}){progress} @{info['assignee']}")
+        task_count += 1
+        for child in info["children"]:
+            if child in all_task_data:
+                _print_task_tree(child, indent + 1)
+
+    for dir_name in sorted(all_task_data.keys()):
+        if not all_task_data[dir_name]["parent"]:
+            _print_task_tree(dir_name)
 
     if task_count == 0:
         lines.append("(no active tasks)")
@@ -302,7 +337,9 @@ def get_context_text(repo_root: Path | None = None) -> str:
                         if assignee == developer and status != "done":
                             title = data.get("title") or data.get("name") or "unknown"
                             priority = data.get("priority", "P2")
-                            lines.append(f"- [{priority}] {title} ({status})")
+                            children_list = data.get("children", [])
+                            progress = _children_progress(children_list) if children_list else ""
+                            lines.append(f"- [{priority}] {title} ({status}){progress}")
                             my_task_count += 1
 
     if my_task_count == 0:
@@ -335,6 +372,91 @@ def get_context_text(repo_root: Path | None = None) -> str:
     return "\n".join(lines)
 
 
+def get_context_record_json(repo_root: Path | None = None) -> dict:
+    """Get record-mode context as a dictionary.
+
+    Focused on: my active tasks, git status, current task.
+    """
+    if repo_root is None:
+        repo_root = get_repo_root()
+
+    developer = get_developer(repo_root)
+    tasks_dir = get_tasks_dir(repo_root)
+
+    # Git info
+    _, branch_out, _ = _run_git_command(["branch", "--show-current"], cwd=repo_root)
+    branch = branch_out.strip() or "unknown"
+
+    _, status_out, _ = _run_git_command(["status", "--porcelain"], cwd=repo_root)
+    git_status_count = len([line for line in status_out.splitlines() if line.strip()])
+
+    _, log_out, _ = _run_git_command(["log", "--oneline", "-5"], cwd=repo_root)
+    commits = []
+    for line in log_out.splitlines():
+        if line.strip():
+            parts = line.split(" ", 1)
+            if len(parts) >= 2:
+                commits.append({"hash": parts[0], "message": parts[1]})
+
+    # My tasks
+    my_tasks = []
+    all_task_statuses: dict[str, str] = {}
+    if tasks_dir.is_dir():
+        for d in sorted(tasks_dir.iterdir()):
+            if d.is_dir() and d.name != "archive":
+                t_json = d / FILE_TASK_JSON
+                if t_json.is_file():
+                    data = _read_json_file(t_json)
+                    if data:
+                        all_task_statuses[d.name] = data.get("status", "unknown")
+
+    if tasks_dir.is_dir():
+        for d in sorted(tasks_dir.iterdir()):
+            if d.is_dir() and d.name != "archive":
+                t_json = d / FILE_TASK_JSON
+                if t_json.is_file():
+                    data = _read_json_file(t_json)
+                    if data and data.get("assignee") == developer:
+                        children_list = data.get("children", [])
+                        done = sum(1 for c in children_list if all_task_statuses.get(c) in ("completed", "done"))
+                        my_tasks.append({
+                            "dir": d.name,
+                            "title": data.get("title") or data.get("name") or "unknown",
+                            "status": data.get("status", "unknown"),
+                            "priority": data.get("priority", "P2"),
+                            "children": children_list,
+                            "childrenDone": done,
+                            "parent": data.get("parent"),
+                            "meta": data.get("meta", {}),
+                        })
+
+    # Current task
+    current_task_info = None
+    current_task = get_current_task(repo_root)
+    if current_task:
+        task_json_path = (repo_root / current_task) / FILE_TASK_JSON
+        if task_json_path.is_file():
+            data = _read_json_file(task_json_path)
+            if data:
+                current_task_info = {
+                    "path": current_task,
+                    "name": data.get("name") or data.get("id") or "unknown",
+                    "status": data.get("status", "unknown"),
+                }
+
+    return {
+        "developer": developer or "",
+        "git": {
+            "branch": branch,
+            "isClean": git_status_count == 0,
+            "uncommittedChanges": git_status_count,
+            "recentCommits": commits,
+        },
+        "myTasks": my_tasks,
+        "currentTask": current_task_info,
+    }
+
+
 def get_context_text_record(repo_root: Path | None = None) -> str:
     """Get context as formatted text for record-session mode.
 
@@ -371,6 +493,26 @@ def get_context_text_record(repo_root: Path | None = None) -> str:
     tasks_dir = get_tasks_dir(repo_root)
     my_task_count = 0
 
+    # Collect task data for children progress
+    all_task_statuses: dict[str, str] = {}
+    if tasks_dir.is_dir():
+        for d in sorted(tasks_dir.iterdir()):
+            if d.is_dir() and d.name != "archive":
+                t_json = d / FILE_TASK_JSON
+                if t_json.is_file():
+                    data = _read_json_file(t_json)
+                    if data:
+                        all_task_statuses[d.name] = data.get("status", "unknown")
+
+    def _record_children_progress(children_list: list[str]) -> str:
+        if not children_list:
+            return ""
+        done = 0
+        for c in children_list:
+            if all_task_statuses.get(c) in ("completed", "done"):
+                done += 1
+        return f" [{done}/{len(children_list)} done]"
+
     if tasks_dir.is_dir():
         for d in sorted(tasks_dir.iterdir()):
             if d.is_dir() and d.name != "archive":
@@ -384,7 +526,9 @@ def get_context_text_record(repo_root: Path | None = None) -> str:
                         if assignee == developer:
                             title = data.get("title") or data.get("name") or "unknown"
                             priority = data.get("priority", "P2")
-                            lines.append(f"- [{priority}] {title} ({status}) — {d.name}")
+                            children_list = data.get("children", [])
+                            progress = _record_children_progress(children_list) if children_list else ""
+                            lines.append(f"- [{priority}] {title} ({status}){progress} — {d.name}")
                             my_task_count += 1
 
     if my_task_count == 0:
@@ -469,7 +613,7 @@ def main() -> None:
         "--json",
         "-j",
         action="store_true",
-        help="Output context in JSON format",
+        help="Output in JSON format (works with any --mode)",
     )
     parser.add_argument(
         "--mode",
@@ -481,12 +625,16 @@ def main() -> None:
 
     args = parser.parse_args()
 
-    if args.json:
-        output_json()
-    elif args.mode == "record":
-        print(get_context_text_record())
+    if args.mode == "record":
+        if args.json:
+            print(json.dumps(get_context_record_json(), indent=2, ensure_ascii=False))
+        else:
+            print(get_context_text_record())
     else:
-        output_text()
+        if args.json:
+            output_json()
+        else:
+            output_text()
 
 
 if __name__ == "__main__":

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

@@ -86,6 +86,8 @@ def list_tasks_by_status(
             "status": status,
             "assignee": assignee,
             "dir": d.name,
+            "children": data.get("children", []),
+            "parent": data.get("parent"),
         })
 
     return results
@@ -161,6 +163,8 @@ def list_tasks_by_assignee(
             "status": status,
             "assignee": task_assignee,
             "dir": d.name,
+            "children": data.get("children", []),
+            "parent": data.get("parent"),
         })
 
     return results

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

@@ -26,39 +26,106 @@ from .paths import (
 # =============================================================================
 
 def parse_simple_yaml(content: str) -> dict:
-    """Parse simple YAML (only supports key: value and lists).
+    """Parse simple YAML with nested dict support (no dependencies).
+
+    Supports:
+        - key: value (string)
+        - key: (followed by list items)
+            - item1
+            - item2
+        - key: (followed by nested dict)
+            nested_key: value
+            nested_key2:
+              - item
+
+    Uses indentation to detect nesting (2+ spaces deeper = child).
 
     Args:
         content: YAML content string.
 
     Returns:
-        Parsed dict.
+        Parsed dict (values can be str, list[str], or dict).
     """
+    lines = content.splitlines()
     result: dict = {}
+    _parse_yaml_block(lines, 0, 0, result)
+    return result
+
+
+def _parse_yaml_block(
+    lines: list[str], start: int, min_indent: int, target: dict
+) -> int:
+    """Parse a YAML block into target dict, returning next line index."""
+    i = start
     current_list: list | None = None
 
-    for line in content.splitlines():
+    while i < len(lines):
+        line = lines[i]
         stripped = line.strip()
+
+        # Skip empty lines and comments
         if not stripped or stripped.startswith("#"):
+            i += 1
             continue
 
+        # Calculate indentation
+        indent = len(line) - len(line.lstrip())
+
+        # If dedented past our block, we're done
+        if indent < min_indent:
+            break
+
         if stripped.startswith("- "):
             if current_list is not None:
                 current_list.append(stripped[2:].strip().strip('"').strip("'"))
+            i += 1
         elif ":" in stripped:
             key, _, value = stripped.partition(":")
             key = key.strip()
             value = value.strip().strip('"').strip("'")
+            current_list = None
+
             if value:
-                result[key] = value
-                _ = None
-                current_list = None
+                # key: value
+                target[key] = value
+                i += 1
             else:
-                _ = key
-                current_list = []
-                result[key] = current_list
-
-    return result
+                # key: (no value) — peek ahead to determine list vs nested dict
+                next_i, next_line = _next_content_line(lines, i + 1)
+                if next_i >= len(lines):
+                    target[key] = {}
+                    i = next_i
+                elif next_line.strip().startswith("- "):
+                    # It's a list
+                    current_list = []
+                    target[key] = current_list
+                    i += 1
+                else:
+                    next_indent = len(next_line) - len(next_line.lstrip())
+                    if next_indent > indent:
+                        # It's a nested dict
+                        nested: dict = {}
+                        target[key] = nested
+                        i = _parse_yaml_block(lines, i + 1, next_indent, nested)
+                    else:
+                        # Empty value, same or less indent follows
+                        target[key] = {}
+                        i += 1
+        else:
+            i += 1
+
+    return i
+
+
+def _next_content_line(lines: list[str], start: int) -> tuple[int, str]:
+    """Find the next non-empty, non-comment line."""
+    i = start
+    while i < len(lines):
+        stripped = lines[i].strip()
+        if stripped and not stripped.startswith("#"):
+            return i, lines[i]
+        i += 1
+    return i, ""
 
 
 def _yaml_get_value(config_file: Path, key: str) -> str | None:

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

@@ -228,8 +228,11 @@ def write_task_json(task_dir: Path, developer: str, project_type: str) -> None:
         "completedAt": None,
         "commit": None,
         "subtasks": subtasks,
+        "children": [],
+        "parent": None,
         "relatedFiles": related_files,
         "notes": f"First-time setup task created by trellis init ({project_type} project)",
+        "meta": {},
     }
 
     task_json = task_dir / "task.json"