@blxzer/cursor-trellis 0.3.4 → 0.3.6

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

@@ -20,6 +20,7 @@ from .paths import DIR_WORKFLOW, DIR_WORKSPACE, FILE_JOURNAL_PREFIX, get_develop
 
 
 SECTION_NAMES = {"summary", "main changes", "git commits", "testing", "status", "next steps"}
+JOURNAL_SNIPPET_MAX_TOKENS = 150
 FIELD_WEIGHTS = {
     "title": 8,
     "task": 8,
@@ -337,6 +338,31 @@ def normalize_space(value: str) -> str:
     return re.sub(r"\s+", " ", value).strip()
 
 
+def truncate_to_token_budget(text: str, max_tokens: int = JOURNAL_SNIPPET_MAX_TOKENS) -> str:
+    """Collapse whitespace and hard-cap by whitespace-split token count."""
+    normalized = normalize_space(text)
+    if not normalized:
+        return ""
+    tokens = normalized.split()
+    if len(tokens) <= max_tokens:
+        return normalized
+    return " ".join(tokens[:max_tokens])
+
+
+def get_latest_journal_summary(
+    journal_path: Path,
+    repo_root: Path,
+    developer: str,
+    max_tokens: int = JOURNAL_SNIPPET_MAX_TOKENS,
+) -> str:
+    """Return the latest session summary from one journal file (≤ max_tokens)."""
+    entries = parse_journal(journal_path, repo_root, developer)
+    if not entries:
+        return ""
+    summary = entries[-1].sections.get("summary", "")
+    return truncate_to_token_budget(summary, max_tokens)
+
+
 def to_repo_path(path: Path, repo_root: Path) -> str:
     try:
         return path.resolve().relative_to(repo_root.resolve()).as_posix()

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

@@ -12,6 +12,11 @@ import sys
 from pathlib import Path
 from typing import Literal
 
+from .injection_budget import (
+    JSONL_MAX_ENTRIES,
+    JSONL_MAX_FILE_CHARS,
+    JSONL_MAX_TOTAL_CHARS,
+)
 from .io import read_json
 from .paths import FILE_TASK_JSON
 
@@ -87,7 +92,8 @@ def read_jsonl_entries(
     jsonl_path: str,
     *,
     warn_prefix: str = "subagent-dispatch",
-) -> list[tuple[str, str]]:
+    apply_budget: bool = True,
+) -> tuple[list[tuple[str, str]], list[str]]:
     full_path = os.path.join(base_path, jsonl_path)
     if not os.path.exists(full_path):
         print(
@@ -95,10 +101,13 @@ def read_jsonl_entries(
             "sub-agent will receive only task artifacts",
             file=sys.stderr,
         )
-        return []
+        return [], []
 
     results: list[tuple[str, str]] = []
+    skipped: list[str] = []
     saw_real_entry = False
+    loaded_entries = 0
+    total_chars = 0
     try:
         with open(full_path, "r", encoding="utf-8") as f:
             for line in f:
@@ -112,12 +121,38 @@ def read_jsonl_entries(
                     if not file_path:
                         continue
                     saw_real_entry = True
+                    if apply_budget and loaded_entries >= JSONL_MAX_ENTRIES:
+                        skipped.append(f"{file_path}: entry cap ({JSONL_MAX_ENTRIES})")
+                        continue
+
+                    expanded: list[tuple[str, str]] = []
                     if entry_type == "directory":
-                        results.extend(read_directory_contents(base_path, file_path))
+                        expanded = read_directory_contents(base_path, file_path)
                     else:
                         content = read_file_content(base_path, file_path)
                         if content:
-                            results.append((file_path, content))
+                            expanded = [(file_path, content)]
+
+                    if not expanded:
+                        skipped.append(f"{file_path}: missing or empty")
+                        continue
+
+                    block_chars = sum(len(content) for _, content in expanded)
+                    if apply_budget and block_chars > JSONL_MAX_FILE_CHARS:
+                        skipped.append(
+                            f"{file_path}: file cap ({block_chars}>{JSONL_MAX_FILE_CHARS} chars)"
+                        )
+                        continue
+                    if apply_budget and total_chars + block_chars > JSONL_MAX_TOTAL_CHARS:
+                        skipped.append(
+                            f"{file_path}: total cap "
+                            f"({total_chars + block_chars}>{JSONL_MAX_TOTAL_CHARS})"
+                        )
+                        continue
+
+                    results.extend(expanded)
+                    total_chars += block_chars
+                    loaded_entries += 1
                 except json.JSONDecodeError:
                     continue
     except OSError:
@@ -129,13 +164,23 @@ def read_jsonl_entries(
             "(only seed / empty) — sub-agent will receive only task artifacts.",
             file=sys.stderr,
         )
-    return results
+    elif apply_budget and (results or skipped):
+        loaded_paths = ", ".join(path for path, _ in results) or "(none)"
+        print(
+            f"[{warn_prefix}] injection-budget: {jsonl_path} "
+            f"loaded {loaded_entries} entries ({total_chars} chars): {loaded_paths}",
+            file=sys.stderr,
+        )
+        for reason in skipped:
+            print(f"[{warn_prefix}] injection-budget: skipped {reason}", file=sys.stderr)
+    return results, skipped
 
 
 def get_agent_context(repo_root: str, task_dir: str, agent_type: str) -> str:
     context_parts: list[str] = []
     agent_jsonl = f"{task_dir}/{agent_type}.jsonl"
-    for file_path, content in read_jsonl_entries(repo_root, agent_jsonl):
+    entries, _ = read_jsonl_entries(repo_root, agent_jsonl)
+    for file_path, content in entries:
         context_parts.append(f"=== {file_path} ===\n{content}")
     return "\n\n".join(context_parts)
 
@@ -166,7 +211,8 @@ def get_implement_context(repo_root: str, task_dir: str) -> str:
 
 def get_check_context(repo_root: str, task_dir: str) -> str:
     context_parts: list[str] = []
-    for file_path, content in read_jsonl_entries(repo_root, f"{task_dir}/check.jsonl"):
+    entries, _ = read_jsonl_entries(repo_root, f"{task_dir}/check.jsonl")
+    for file_path, content in entries:
         context_parts.append(f"=== {file_path} ===\n{content}")
 
     prd_content = read_file_content(repo_root, f"{task_dir}/prd.md")
@@ -192,7 +238,25 @@ def get_finish_context(repo_root: str, task_dir: str) -> str:
 
 
 def get_research_context(repo_root: str, task_dir: str | None) -> str:
-    _ = task_dir
+    context_parts: list[str] = []
+
+    if task_dir:
+        entries, _ = read_jsonl_entries(repo_root, f"{task_dir}/research.jsonl")
+        for file_path, content in entries:
+            context_parts.append(f"=== {file_path} ===\n{content}")
+
+        prd_content = read_file_content(repo_root, f"{task_dir}/prd.md")
+        if prd_content:
+            context_parts.append(
+                f"=== {task_dir}/prd.md (Requirements) ===\n{prd_content}"
+            )
+
+        design_content = read_file_content(repo_root, f"{task_dir}/design.md")
+        if design_content:
+            context_parts.append(
+                f"=== {task_dir}/design.md (Technical Design) ===\n{design_content}"
+            )
+
     spec_path = f"{DIR_WORKFLOW}/{DIR_SPEC}"
     spec_root = Path(repo_root) / DIR_WORKFLOW / DIR_SPEC
 
@@ -219,7 +283,8 @@ To get structured package info, run: `python ./{DIR_WORKFLOW}/scripts/get_contex
 - Spec files: `{spec_path}/**/*.md`
 - Code search: Use Glob and Grep tools
 - External facts / docs: load `smart-search-cli` skill and use Bash (`smart-search` CLI), not Cursor WebSearch/WebFetch by default"""
-    return project_structure
+    context_parts.append(project_structure)
+    return "\n\n".join(context_parts)
 
 
 def build_implement_prompt(original_prompt: str, context: str) -> str:

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

@@ -24,6 +24,11 @@ from pathlib import Path
 from .log import Colors, colored
 from .paths import get_repo_root
 from .task_utils import resolve_task_dir
+from .injection_budget import (
+    JSONL_MAX_ENTRIES,
+    JSONL_MAX_TOTAL_CHARS,
+    measure_jsonl_manifest,
+)
 
 
 # =============================================================================
@@ -159,6 +164,19 @@ def _validate_jsonl(jsonl_file: Path, repo_root: Path) -> int:
 
     if errors == 0:
         print(f"  {colored(f'{file_name}: ✓ ({real_entries} entries)', Colors.GREEN)}")
+        budget = measure_jsonl_manifest(repo_root, jsonl_file.parent, file_name)
+        if real_entries > JSONL_MAX_ENTRIES:
+            print(
+                f"  {colored(f'{file_name}: budget WARN — {real_entries} entries (max {JSONL_MAX_ENTRIES})', Colors.YELLOW)}"
+            )
+        if budget.expanded_chars > JSONL_MAX_TOTAL_CHARS:
+            print(
+                f"  {colored(f'{file_name}: budget WARN — expanded {budget.expanded_chars} chars (max {JSONL_MAX_TOTAL_CHARS})', Colors.YELLOW)}"
+            )
+        elif budget.skipped:
+            print(
+                f"  {colored(f'{file_name}: budget WARN — {len(budget.skipped)} entries would be skipped at dispatch', Colors.YELLOW)}"
+            )
     else:
         print(f"  {colored(f'{file_name}: ✗ ({errors} errors)', Colors.RED)}")
 

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

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from .active_task import resolve_selected_task
 from .paths import DIR_TASKS, DIR_WORKFLOW, get_developer, get_repo_root, get_tasks_dir
+from .task_gates import verify_evidence_status
 from .task_map import get_child_state
 from .tasks import (
     children_progress,
@@ -23,6 +24,19 @@ def _task_path(dir_name: str) -> str:
     return f"{DIR_WORKFLOW}/{DIR_TASKS}/{dir_name}"
 
 
+def format_verify_summary(task_dir: Path, task_data: dict) -> str:
+    """Return a compact verify evidence label for dashboard task lines."""
+    verify_path = task_dir / "verify.md"
+    if not verify_path.is_file():
+        return "[verify: missing]"
+    status = verify_evidence_status(task_dir, task_data)
+    if all(status.values()):
+        return "[verify: ok]"
+    if any(status.values()):
+        return "[verify: partial]"
+    return "[verify: missing]"
+
+
 def _selected_line(
     repo_root: Path,
     platform_input: dict | None = None,
@@ -123,9 +137,10 @@ def _append_task(
         integration_state = get_child_state(parent_dir, name)
     status_display = format_child_task_display(task.status, integration_state)
     assignee = task.assignee or "-"
+    verify_summary = format_verify_summary(task.directory, task.raw or {})
     prefix = "  " * indent + "  - "
     lines.append(
-        f"{prefix}{_task_path(name)} ({status_display}){progress} [{assignee}]"
+        f"{prefix}{_task_path(name)} ({status_display}){progress} [{assignee}] {verify_summary}"
     )
     for child_name in task.children:
         if child_name in all_tasks: