@mindfoldhq/trellis 0.1.9 → 0.2.2

package/dist/templates/claude/commands/start.md

@@ -35,14 +35,14 @@ cat .trellis/workflow.md
 ./.trellis/scripts/get-context.sh
 ```
 
-This shows: developer identity, git status, current feature (if any), backlog items.
+This shows: developer identity, git status, current task (if any), active tasks.
 
 ### Step 3: Read Guidelines Index
 
 ```bash
-cat .trellis/structure/frontend/index.md  # Frontend guidelines
-cat .trellis/structure/backend/index.md   # Backend guidelines
-cat .trellis/structure/guides/index.md    # Thinking guides
+cat .trellis/spec/frontend/index.md  # Frontend guidelines
+cat .trellis/spec/backend/index.md   # Backend guidelines
+cat .trellis/spec/guides/index.md    # Thinking guides
 ```
 
 ### Step 4: Report and Ask
@@ -59,13 +59,13 @@ When user describes a task, classify it:
 |------|----------|----------|
 | **Question** | User asks about code, architecture, or how something works | Answer directly |
 | **Trivial Fix** | Typo fix, comment update, single-line change, < 5 minutes | Direct Edit |
-| **Development Task** | Any code change that: modifies logic, adds features, fixes bugs, touches multiple files | **Feature Workflow** |
+| **Development Task** | Any code change that: modifies logic, adds features, fixes bugs, touches multiple files | **Task Workflow** |
 
 ### Decision Rule
 
-> **If in doubt, use Feature Workflow.**
+> **If in doubt, use Task Workflow.**
 >
-> Feature Workflow ensures specs are injected to agents, resulting in higher quality code.
+> Task Workflow ensures specs are injected to agents, resulting in higher quality code.
 > The overhead is minimal, but the benefit is significant.
 
 ---
@@ -79,7 +79,7 @@ For questions or trivial fixes, work directly:
 
 ---
 
-## Feature Workflow (Development Tasks)
+## Task Workflow (Development Tasks)
 
 **Why this workflow?**
 - Research Agent analyzes what specs are needed
@@ -110,7 +110,7 @@ Task(
   Type: <frontend/backend/fullstack>
 
   Please find:
-  1. Relevant spec files in .trellis/structure/
+  1. Relevant spec files in .trellis/spec/
   2. Existing code patterns to follow (find 2-3 examples)
   3. Files that will likely need modification
 
@@ -124,18 +124,18 @@ Task(
   ## Files to Modify
   - <path>: <what change>
 
-  ## Suggested Feature Name
+  ## Suggested Task Name
   - <short-slug-name>",
   model: "opus"
 )
 ```
 
-### Step 3: Create Feature Directory `[AI]`
+### Step 3: Create Task Directory `[AI]`
 
 Based on research results:
 
 ```bash
-FEATURE_DIR=$(./.trellis/scripts/feature.sh create "<title from research>" --slug <suggested-slug>)
+TASK_DIR=$(./.trellis/scripts/task.sh create "<title from research>" --slug <suggested-slug>)
 ```
 
 ### Step 4: Configure Context `[AI]`
@@ -143,7 +143,7 @@ FEATURE_DIR=$(./.trellis/scripts/feature.sh create "<title from research>" --slu
 Initialize default context:
 
 ```bash
-./.trellis/scripts/feature.sh init-context "$FEATURE_DIR" <type>
+./.trellis/scripts/task.sh init-context "$TASK_DIR" <type>
 # type: backend | frontend | fullstack
 ```
 
@@ -151,16 +151,16 @@ Add specs found by Research Agent:
 
 ```bash
 # For each relevant spec and code pattern:
-./.trellis/scripts/feature.sh add-context "$FEATURE_DIR" implement "<path>" "<reason>"
-./.trellis/scripts/feature.sh add-context "$FEATURE_DIR" check "<path>" "<reason>"
+./.trellis/scripts/task.sh add-context "$TASK_DIR" implement "<path>" "<reason>"
+./.trellis/scripts/task.sh add-context "$TASK_DIR" check "<path>" "<reason>"
 ```
 
 ### Step 5: Write Requirements `[AI]`
 
-Create `prd.md` in the feature directory with:
+Create `prd.md` in the task directory with:
 
 ```markdown
-# <Feature Title>
+# <Task Title>
 
 ## Goal
 <What we're trying to achieve>
@@ -177,13 +177,13 @@ Create `prd.md` in the feature directory with:
 <Any technical decisions or constraints>
 ```
 
-### Step 6: Activate Feature `[AI]`
+### Step 6: Activate Task `[AI]`
 
 ```bash
-./.trellis/scripts/feature.sh start "$FEATURE_DIR"
+./.trellis/scripts/task.sh start "$TASK_DIR"
 ```
 
-This sets `.current-feature` so hooks can inject context.
+This sets `.current-task` so hooks can inject context.
 
 ### Step 7: Implement `[AI]`
 
@@ -192,7 +192,7 @@ Call Implement Agent (specs are auto-injected by hook):
 ```
 Task(
   subagent_type: "implement",
-  prompt: "Implement the feature described in prd.md.
+  prompt: "Implement the task described in prd.md.
 
   Follow all specs that have been injected into your context.
   Run lint and typecheck before finishing.",
@@ -222,17 +222,17 @@ Task(
 3. Remind user to:
    - Test the changes
    - Commit when ready
-   - Run `/record-agent-flow` to record this session
+   - Run `/record-session` to record this session
 
 ---
 
-## Continuing Existing Feature
+## Continuing Existing Task
 
-If `get-context.sh` shows a current feature:
+If `get-context.sh` shows a current task:
 
-1. Read the feature's `prd.md` to understand the goal
-2. Check `feature.json` for current status and phase
-3. Ask user: "Continue working on <feature-name>?"
+1. Read the task's `prd.md` to understand the goal
+2. Check `task.json` for current status and phase
+3. Ask user: "Continue working on <task-name>?"
 
 If yes, resume from the appropriate step (usually Step 7 or 8).
 
@@ -245,21 +245,21 @@ If yes, resume from the appropriate step (usually Step 7 or 8).
 | Command | When to Use |
 |---------|-------------|
 | `/start` | Begin a session (this command) |
-| `/parallel` | Complex features needing isolated worktree |
+| `/parallel` | Complex tasks needing isolated worktree |
 | `/finish-work` | Before committing changes |
-| `/record-agent-flow` | After completing a task |
+| `/record-session` | After completing a task |
 
 ### AI Scripts `[AI]`
 
 | Script | Purpose |
 |--------|---------|
 | `get-context.sh` | Get session context |
-| `feature.sh create` | Create feature directory |
-| `feature.sh init-context` | Initialize jsonl files |
-| `feature.sh add-context` | Add spec to jsonl |
-| `feature.sh start` | Set current feature |
-| `feature.sh finish` | Clear current feature |
-| `feature.sh archive` | Archive completed feature |
+| `task.sh create` | Create task directory |
+| `task.sh init-context` | Initialize jsonl files |
+| `task.sh add-context` | Add spec to jsonl |
+| `task.sh start` | Set current task |
+| `task.sh finish` | Clear current task |
+| `task.sh archive` | Archive completed task |
 
 ### Sub Agents `[AI]`
 
@@ -276,5 +276,5 @@ If yes, resume from the appropriate step (usually Step 7 or 8).
 
 > **Specs are injected, not remembered.**
 >
-> The Feature Workflow ensures agents receive relevant specs automatically.
+> The Task Workflow ensures agents receive relevant specs automatically.
 > This is more reliable than hoping the AI "remembers" conventions.

package/dist/templates/claude/hooks/inject-subagent-context.py

@@ -10,7 +10,7 @@ Core Design Philosophy:
 
 Trigger: PreToolUse (before Task tool call)
 
-Context Source: .trellis/.current-feature points to feature directory
+Context Source: .trellis/.current-task points to task directory
 - implement.jsonl - Implement agent dedicated context
 - check.jsonl     - Check agent dedicated context
 - debug.jsonl     - Debug agent dedicated context
@@ -31,10 +31,11 @@ from pathlib import Path
 # =============================================================================
 
 DIR_WORKFLOW = ".trellis"
-DIR_PROGRESS = "agent-traces"
-DIR_FEATURES = "features"
-DIR_STRUCTURE = "structure"
-FILE_CURRENT_FEATURE = ".current-feature"
+DIR_WORKSPACE = "workspace"
+DIR_TASKS = "tasks"
+DIR_SPEC = "spec"
+FILE_CURRENT_TASK = ".current-task"
+FILE_TASK_JSON = "task.json"
 
 # Agents that don't update phase (can be called at any time)
 AGENTS_NO_PHASE_UPDATE = {"debug", "research"}
@@ -48,8 +49,8 @@ AGENT_CHECK = "check"
 AGENT_DEBUG = "debug"
 AGENT_RESEARCH = "research"
 
-# Agents that require a feature directory
-AGENTS_REQUIRE_FEATURE = (AGENT_IMPLEMENT, AGENT_CHECK, AGENT_DEBUG)
+# Agents that require a task directory
+AGENTS_REQUIRE_TASK = (AGENT_IMPLEMENT, AGENT_CHECK, AGENT_DEBUG)
 # All supported agents
 AGENTS_ALL = (AGENT_IMPLEMENT, AGENT_CHECK, AGENT_DEBUG, AGENT_RESEARCH)
 
@@ -69,35 +70,35 @@ def find_repo_root(start_path: str) -> str | None:
     return None
 
 
-def get_current_feature(repo_root: str) -> str | None:
+def get_current_task(repo_root: str) -> str | None:
     """
-    Read current feature directory path from .trellis/.current-feature
+    Read current task directory path from .trellis/.current-task
 
     Returns:
-        Feature directory relative path (relative to repo_root)
+        Task directory relative path (relative to repo_root)
         None if not set
     """
-    current_feature_file = os.path.join(repo_root, DIR_WORKFLOW, FILE_CURRENT_FEATURE)
-    if not os.path.exists(current_feature_file):
+    current_task_file = os.path.join(repo_root, DIR_WORKFLOW, FILE_CURRENT_TASK)
+    if not os.path.exists(current_task_file):
         return None
 
     try:
-        with open(current_feature_file, "r", encoding="utf-8") as f:
+        with open(current_task_file, "r", encoding="utf-8") as f:
             content = f.read().strip()
             return content if content else None
     except Exception:
         return None
 
 
-def update_current_phase(repo_root: str, feature_dir: str, subagent_type: str) -> None:
+def update_current_phase(repo_root: str, task_dir: str, subagent_type: str) -> None:
     """
-    Update current_phase in feature.json based on subagent_type.
+    Update current_phase in task.json based on subagent_type.
 
     This ensures phase tracking is always accurate, regardless of whether
     dispatch agent remembers to update it.
 
     Logic:
-    - Read next_action array from feature.json
+    - Read next_action array from task.json
     - Find the next phase whose action matches subagent_type
     - Only move forward, never backward
     - Some agents (debug, research) don't update phase
@@ -105,16 +106,16 @@ def update_current_phase(repo_root: str, feature_dir: str, subagent_type: str) -
     if subagent_type in AGENTS_NO_PHASE_UPDATE:
         return
 
-    feature_json_path = os.path.join(repo_root, feature_dir, "feature.json")
-    if not os.path.exists(feature_json_path):
+    task_json_path = os.path.join(repo_root, task_dir, FILE_TASK_JSON)
+    if not os.path.exists(task_json_path):
         return
 
     try:
-        with open(feature_json_path, "r", encoding="utf-8") as f:
-            feature_data = json.load(f)
+        with open(task_json_path, "r", encoding="utf-8") as f:
+            task_data = json.load(f)
 
-        current_phase = feature_data.get("current_phase", 0)
-        next_actions = feature_data.get("next_action", [])
+        current_phase = task_data.get("current_phase", 0)
+        next_actions = task_data.get("next_action", [])
 
         # Map action names to subagent types
         # "implement" -> "implement", "check" -> "check", "finish" -> "check"
@@ -137,10 +138,10 @@ def update_current_phase(repo_root: str, feature_dir: str, subagent_type: str) -
                 break
 
         if new_phase is not None:
-            feature_data["current_phase"] = new_phase
+            task_data["current_phase"] = new_phase
 
-            with open(feature_json_path, "w", encoding="utf-8") as f:
-                json.dump(feature_data, f, indent=2, ensure_ascii=False)
+            with open(task_json_path, "w", encoding="utf-8") as f:
+                json.dump(task_data, f, indent=2, ensure_ascii=False)
     except Exception:
         # Don't fail the hook if phase update fails
         pass
@@ -249,7 +250,7 @@ def read_jsonl_entries(base_path: str, jsonl_path: str) -> list[tuple[str, str]]
     return results
 
 
-def get_agent_context(repo_root: str, feature_dir: str, agent_type: str) -> str:
+def get_agent_context(repo_root: str, task_dir: str, agent_type: str) -> str:
     """
     Get complete context for specified agent
 
@@ -258,12 +259,12 @@ def get_agent_context(repo_root: str, feature_dir: str, agent_type: str) -> str:
     context_parts = []
 
     # 1. Try agent-specific jsonl
-    agent_jsonl = f"{feature_dir}/{agent_type}.jsonl"
+    agent_jsonl = f"{task_dir}/{agent_type}.jsonl"
     agent_entries = read_jsonl_entries(repo_root, agent_jsonl)
 
     # 2. If agent-specific jsonl doesn't exist or empty, fallback to spec.jsonl
     if not agent_entries:
-        agent_entries = read_jsonl_entries(repo_root, f"{feature_dir}/spec.jsonl")
+        agent_entries = read_jsonl_entries(repo_root, f"{task_dir}/spec.jsonl")
 
     # 3. Add all files from jsonl
     for file_path, content in agent_entries:
@@ -272,7 +273,7 @@ def get_agent_context(repo_root: str, feature_dir: str, agent_type: str) -> str:
     return "\n\n".join(context_parts)
 
 
-def get_implement_context(repo_root: str, feature_dir: str) -> str:
+def get_implement_context(repo_root: str, task_dir: str) -> str:
     """
     Complete context for Implement Agent
 
@@ -284,39 +285,39 @@ def get_implement_context(repo_root: str, feature_dir: str) -> str:
     context_parts = []
 
     # 1. Read implement.jsonl (or fallback to spec.jsonl)
-    base_context = get_agent_context(repo_root, feature_dir, "implement")
+    base_context = get_agent_context(repo_root, task_dir, "implement")
     if base_context:
         context_parts.append(base_context)
 
     # 2. Requirements document
-    prd_content = read_file_content(repo_root, f"{feature_dir}/prd.md")
+    prd_content = read_file_content(repo_root, f"{task_dir}/prd.md")
     if prd_content:
         context_parts.append(
-            f"=== {feature_dir}/prd.md (Requirements) ===\n{prd_content}"
+            f"=== {task_dir}/prd.md (Requirements) ===\n{prd_content}"
         )
 
     # 3. Technical design
-    info_content = read_file_content(repo_root, f"{feature_dir}/info.md")
+    info_content = read_file_content(repo_root, f"{task_dir}/info.md")
     if info_content:
         context_parts.append(
-            f"=== {feature_dir}/info.md (Technical Design) ===\n{info_content}"
+            f"=== {task_dir}/info.md (Technical Design) ===\n{info_content}"
         )
 
     return "\n\n".join(context_parts)
 
 
-def get_check_context(repo_root: str, feature_dir: str) -> str:
+def get_check_context(repo_root: str, task_dir: str) -> str:
     """
     Complete context for Check Agent
 
     Read order:
     1. All files in check.jsonl (check specs + dev specs)
-    2. prd.md (for understanding feature intent)
+    2. prd.md (for understanding task intent)
     """
     context_parts = []
 
     # 1. Read check.jsonl (or fallback to spec.jsonl + hardcoded check files)
-    check_entries = read_jsonl_entries(repo_root, f"{feature_dir}/check.jsonl")
+    check_entries = read_jsonl_entries(repo_root, f"{task_dir}/check.jsonl")
 
     if check_entries:
         for file_path, content in check_entries:
@@ -335,21 +336,21 @@ def get_check_context(repo_root: str, feature_dir: str) -> str:
                 context_parts.append(f"=== {file_path} ({description}) ===\n{content}")
 
         # Add spec.jsonl
-        spec_entries = read_jsonl_entries(repo_root, f"{feature_dir}/spec.jsonl")
+        spec_entries = read_jsonl_entries(repo_root, f"{task_dir}/spec.jsonl")
         for file_path, content in spec_entries:
             context_parts.append(f"=== {file_path} (Dev spec) ===\n{content}")
 
-    # 2. Requirements document (for understanding feature intent)
-    prd_content = read_file_content(repo_root, f"{feature_dir}/prd.md")
+    # 2. Requirements document (for understanding task intent)
+    prd_content = read_file_content(repo_root, f"{task_dir}/prd.md")
     if prd_content:
         context_parts.append(
-            f"=== {feature_dir}/prd.md (Requirements - for understanding intent) ===\n{prd_content}"
+            f"=== {task_dir}/prd.md (Requirements - for understanding intent) ===\n{prd_content}"
         )
 
     return "\n\n".join(context_parts)
 
 
-def get_finish_context(repo_root: str, feature_dir: str) -> str:
+def get_finish_context(repo_root: str, task_dir: str) -> str:
     """
     Complete context for Finish phase (final check before PR)
 
@@ -361,7 +362,7 @@ def get_finish_context(repo_root: str, feature_dir: str) -> str:
     context_parts = []
 
     # 1. Try finish.jsonl first
-    finish_entries = read_jsonl_entries(repo_root, f"{feature_dir}/finish.jsonl")
+    finish_entries = read_jsonl_entries(repo_root, f"{task_dir}/finish.jsonl")
 
     if finish_entries:
         for file_path, content in finish_entries:
@@ -375,16 +376,16 @@ def get_finish_context(repo_root: str, feature_dir: str) -> str:
             )
 
     # 2. Requirements document (for verifying requirements are met)
-    prd_content = read_file_content(repo_root, f"{feature_dir}/prd.md")
+    prd_content = read_file_content(repo_root, f"{task_dir}/prd.md")
     if prd_content:
         context_parts.append(
-            f"=== {feature_dir}/prd.md (Requirements - verify all met) ===\n{prd_content}"
+            f"=== {task_dir}/prd.md (Requirements - verify all met) ===\n{prd_content}"
         )
 
     return "\n\n".join(context_parts)
 
 
-def get_debug_context(repo_root: str, feature_dir: str) -> str:
+def get_debug_context(repo_root: str, task_dir: str) -> str:
     """
     Complete context for Debug Agent
 
@@ -395,14 +396,14 @@ def get_debug_context(repo_root: str, feature_dir: str) -> str:
     context_parts = []
 
     # 1. Read debug.jsonl (or fallback to spec.jsonl + hardcoded check files)
-    debug_entries = read_jsonl_entries(repo_root, f"{feature_dir}/debug.jsonl")
+    debug_entries = read_jsonl_entries(repo_root, f"{task_dir}/debug.jsonl")
 
     if debug_entries:
         for file_path, content in debug_entries:
             context_parts.append(f"=== {file_path} ===\n{content}")
     else:
         # Fallback: use spec.jsonl + hardcoded check files
-        spec_entries = read_jsonl_entries(repo_root, f"{feature_dir}/spec.jsonl")
+        spec_entries = read_jsonl_entries(repo_root, f"{task_dir}/spec.jsonl")
         for file_path, content in spec_entries:
             context_parts.append(f"=== {file_path} (Dev spec) ===\n{content}")
 
@@ -418,11 +419,11 @@ def get_debug_context(repo_root: str, feature_dir: str) -> str:
 
     # 2. Codex review output (if exists)
     codex_output = read_file_content(
-        repo_root, f"{feature_dir}/codex-review-output.txt"
+        repo_root, f"{task_dir}/codex-review-output.txt"
     )
     if codex_output:
         context_parts.append(
-            f"=== {feature_dir}/codex-review-output.txt (Codex Review Results) ===\n{codex_output}"
+            f"=== {task_dir}/codex-review-output.txt (Codex Review Results) ===\n{codex_output}"
         )
 
     return "\n\n".join(context_parts)
@@ -564,7 +565,7 @@ Dev specs and Codex Review results:
 - Report which issues were fixed and which files were modified"""
 
 
-def get_research_context(repo_root: str, feature_dir: str | None) -> str:
+def get_research_context(repo_root: str, task_dir: str | None) -> str:
     """
     Context for Research Agent
 
@@ -575,11 +576,11 @@ def get_research_context(repo_root: str, feature_dir: str | None) -> str:
     context_parts = []
 
     # 1. Project structure overview (uses constants for paths)
-    structure_path = f"{DIR_WORKFLOW}/{DIR_STRUCTURE}"
+    spec_path = f"{DIR_WORKFLOW}/{DIR_SPEC}"
     project_structure = f"""## Project Spec Directory Structure
 
 ```
-{structure_path}/
+{spec_path}/
 ├── shared/      # Cross-project common specs (TypeScript, code quality, git)
 ├── frontend/    # Frontend standards
 ├── backend/     # Backend standards
@@ -590,17 +591,17 @@ def get_research_context(repo_root: str, feature_dir: str | None) -> str:
 
 ## Search Tips
 
-- Spec files: `{structure_path}/**/*.md`
+- Spec files: `{spec_path}/**/*.md`
 - Known issues: `{DIR_WORKFLOW}/big-question/`
 - Code search: Use Glob and Grep tools
 - Tech solutions: Use mcp__exa__web_search_exa or mcp__exa__get_code_context_exa"""
 
     context_parts.append(project_structure)
 
-    # 2. If feature directory exists, try reading research.jsonl (optional)
-    if feature_dir:
+    # 2. If task directory exists, try reading research.jsonl (optional)
+    if task_dir:
         research_entries = read_jsonl_entries(
-            repo_root, f"{feature_dir}/research.jsonl"
+            repo_root, f"{task_dir}/research.jsonl"
         )
         if research_entries:
             context_parts.append(
@@ -697,46 +698,46 @@ def main():
     if not repo_root:
         sys.exit(0)
 
-    # Get current feature directory (research doesn't require it)
-    feature_dir = get_current_feature(repo_root)
+    # Get current task directory (research doesn't require it)
+    task_dir = get_current_task(repo_root)
 
-    # implement/check/debug need feature directory
-    if subagent_type in AGENTS_REQUIRE_FEATURE:
-        if not feature_dir:
+    # implement/check/debug need task directory
+    if subagent_type in AGENTS_REQUIRE_TASK:
+        if not task_dir:
             sys.exit(0)
-        # Check if feature directory exists
-        feature_dir_full = os.path.join(repo_root, feature_dir)
-        if not os.path.exists(feature_dir_full):
+        # Check if task directory exists
+        task_dir_full = os.path.join(repo_root, task_dir)
+        if not os.path.exists(task_dir_full):
             sys.exit(0)
 
-        # Update current_phase in feature.json (system-level enforcement)
-        update_current_phase(repo_root, feature_dir, subagent_type)
+        # Update current_phase in task.json (system-level enforcement)
+        update_current_phase(repo_root, task_dir, subagent_type)
 
     # Check for [finish] marker in prompt (check agent with finish context)
     is_finish_phase = "[finish]" in original_prompt.lower()
 
     # Get context and build prompt based on subagent type
     if subagent_type == AGENT_IMPLEMENT:
-        assert feature_dir is not None  # validated above
-        context = get_implement_context(repo_root, feature_dir)
+        assert task_dir is not None  # validated above
+        context = get_implement_context(repo_root, task_dir)
         new_prompt = build_implement_prompt(original_prompt, context)
     elif subagent_type == AGENT_CHECK:
-        assert feature_dir is not None  # validated above
+        assert task_dir is not None  # validated above
         if is_finish_phase:
             # Finish phase: use finish context (lighter, focused on final verification)
-            context = get_finish_context(repo_root, feature_dir)
+            context = get_finish_context(repo_root, task_dir)
             new_prompt = build_finish_prompt(original_prompt, context)
         else:
             # Regular check phase: use check context (full specs for self-fix loop)
-            context = get_check_context(repo_root, feature_dir)
+            context = get_check_context(repo_root, task_dir)
             new_prompt = build_check_prompt(original_prompt, context)
     elif subagent_type == AGENT_DEBUG:
-        assert feature_dir is not None  # validated above
-        context = get_debug_context(repo_root, feature_dir)
+        assert task_dir is not None  # validated above
+        context = get_debug_context(repo_root, task_dir)
         new_prompt = build_debug_prompt(original_prompt, context)
     elif subagent_type == AGENT_RESEARCH:
-        # Research can work without feature directory
-        context = get_research_context(repo_root, feature_dir)
+        # Research can work without task directory
+        context = get_research_context(repo_root, task_dir)
         new_prompt = build_research_prompt(original_prompt, context)
     else:
         sys.exit(0)