@pennixrv/trellis 0.7.0-beta.8 → 0.7.1

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

@@ -87,14 +87,6 @@ def find_repo_root(start_path: str) -> str | None:
     return None
 
 
-def _real_path_contained(base_real: str, target_real: str) -> bool:
-    """Return whether a real path is inside the real base path."""
-    try:
-        return os.path.commonpath([base_real, target_real]) == base_real
-    except ValueError:
-        return False
-
-
 def _detect_platform(input_data: dict) -> str | None:
     if _hook_event_name(input_data) == "SubagentStart":
         return "codex"
@@ -149,7 +141,7 @@ def get_current_task(
     input_data: dict,
     *,
     platform: str | None = None,
-    allow_single_session_fallback: bool = False,
+    allow_single_session_fallback: bool = True,
     allow_environment_context: bool = True,
     require_existing: bool = False,
 ) -> str | None:
@@ -175,11 +167,11 @@ def get_current_task(
 
 
 # =============================================================================
-# Context Injection
+# Context Injection Limits (issue #441)
 #
-# The shared Python projection lives in the active project's stamped
-# `.trellis/scripts/common/context_projection.py`. These fallback limits keep
-# the installed Hook fail-open when an older project has not been updated yet.
+# Notice text and behavior mirrored byte-for-byte in the Pi TS extension
+# (templates/pi/extensions/trellis/index.ts.txt). Changing wording here
+# requires changing it there too.
 # =============================================================================
 
 DEFAULT_MAX_FILE_BYTES = 32768
@@ -206,64 +198,455 @@ def _get_limits(repo_root: str) -> dict[str, int]:
         return dict(DEFAULT_LIMITS)
 
 
-def _project_context(repo_root: str, task_dir: str, agent_type: str):
-    """Load the task-owned projection evaluator for the current project.
+def truncate_utf8(data: bytes, cap: int) -> bytes:
+    """Truncate ``data`` to at most ``cap`` bytes without splitting a UTF-8
+    multi-byte sequence.
 
-    Hooks are installed outside the project, so the evaluator deliberately
-    resolves from the active project's stamped `.trellis/scripts` tree.
+    ``cap <= 0`` means "no limit" — returns ``data`` unchanged.
     """
-    scripts_dir = Path(repo_root) / DIR_WORKFLOW / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    from common.context_projection import project_agent_context  # type: ignore[import-not-found]
+    if cap <= 0 or len(data) <= cap:
+        return data
+
+    truncated = data[:cap]
+    i = len(truncated)
+    # Back off over continuation bytes (10xxxxxx) to find the lead byte.
+    while i > 0 and (truncated[i - 1] & 0xC0) == 0x80:
+        i -= 1
+    if i == 0:
+        return b""
+
+    lead = truncated[i - 1]
+    if lead & 0x80:
+        if (lead & 0xE0) == 0xC0:
+            seq_len = 2
+        elif (lead & 0xF0) == 0xE0:
+            seq_len = 3
+        elif (lead & 0xF8) == 0xF0:
+            seq_len = 4
+        else:
+            seq_len = 1
+        # Cut before the lead byte when its full sequence didn't fit;
+        # otherwise the trailing sequence is complete — keep it whole.
+        if (i - 1) + seq_len > len(truncated):
+            return truncated[: i - 1]
+
+    return truncated
+
+
+class _Budget:
+    """Tracks the running total of bytes emitted into the sub-agent context."""
+
+    def __init__(self, max_total_bytes: int) -> None:
+        self.max_total_bytes = max_total_bytes
+        self.used = 0
+
+    def has_room(self, size: int) -> bool:
+        if self.max_total_bytes <= 0:
+            return True
+        return self.used + size <= self.max_total_bytes
+
+    def add(self, size: int) -> None:
+        self.used += size
+
+
+def _real_path_contained(base_real: str, target_real: str) -> bool:
+    """Whether an already-realpath'd target sits under an already-realpath'd base.
+
+    ValueError on Windows when the two sit on different drives; that is
+    outside the base by definition, so it fails closed.
+    """
+    try:
+        return os.path.commonpath([base_real, target_real]) == base_real
+    except ValueError:
+        return False
+
+
+def _read_file_bytes(base_path: str, file_path: str) -> bytes | None:
+    """Read raw file bytes, return None if file doesn't exist."""
+    full_path = os.path.join(base_path, file_path)
+    try:
+        root_real = os.path.realpath(base_path)
+        # `.trellis` may itself be a symlink into a store outside the repo
+        # (#567); its real location is a second legitimate containment base.
+        workflow_real = os.path.realpath(os.path.join(base_path, ".trellis"))
+        full_real = os.path.realpath(full_path)
+        if not _real_path_contained(root_real, full_real) and not (
+            _real_path_contained(workflow_real, full_real)
+        ):
+            return None
+    except OSError:
+        return None
+    if os.path.exists(full_path) and os.path.isfile(full_path):
+        try:
+            with open(full_path, "rb") as f:
+                return f.read()
+        except Exception:
+            return None
+    return None
+
+
+def _truncate_notice(path: str, cap: int) -> str:
+    return f"\n[Trellis: truncated at {cap} bytes — read {path} for the full content]"
+
+
+def _is_binary_content(data: bytes) -> bool:
+    """Return True when raw bytes should not be decoded into model context."""
+    if b"\x00" in data:
+        return True
+    try:
+        data.decode("utf-8", errors="strict")
+    except UnicodeDecodeError:
+        return True
+    return False
+
 
-    return project_agent_context(
-        Path(repo_root), Path(repo_root) / task_dir, agent_type, _get_limits(repo_root)
+def _binary_notice(path: str, size: int, reason: str) -> str:
+    return (
+        f"[Trellis: not inlined (binary file) — "
+        f"{path} ({size} bytes): {reason}]"
     )
 
 
+def _index_notice(path: str, size: int, reason: str) -> str:
+    return (
+        f"[Trellis: not inlined (total context limit reached) — "
+        f"{path} ({size} bytes): {reason}]"
+    )
+
+
+def _budgeted_block(
+    budget: _Budget,
+    header: str,
+    plain_path: str,
+    content: str,
+    reason: str,
+    size_for_index: int,
+) -> str:
+    """Return an inlined ``=== header ===`` block, or degrade to an index
+    notice once the total context budget is exhausted."""
+    block = f"=== {header} ===\n{content}"
+    block_bytes = len(block.encode("utf-8"))
+    if not budget.has_room(block_bytes):
+        notice = _index_notice(plain_path, size_for_index, reason)
+        budget.add(len(notice.encode("utf-8")))
+        return notice
+    budget.add(block_bytes)
+    return block
+
+
+def _materialize_file(
+    base_path: str,
+    file_path: str,
+    reason: str,
+    limits: dict[str, int],
+    budget: _Budget,
+) -> str | None:
+    """Read a JSONL-referenced file, apply the per-file cap, then budget it."""
+    data = _read_file_bytes(base_path, file_path)
+    if data is None:
+        return None
+
+    size = len(data)
+    if _is_binary_content(data):
+        notice = _binary_notice(file_path, size, reason)
+        budget.add(len(notice.encode("utf-8")))
+        return notice
+
+    cap = limits["max_file_bytes"]
+    truncated_bytes = truncate_utf8(data, cap)
+    content = truncated_bytes.decode("utf-8", errors="replace")
+    if len(truncated_bytes) < size:
+        content += _truncate_notice(file_path, cap)
+
+    return _budgeted_block(budget, file_path, file_path, content, reason, size)
+
+
+def _materialize_directory(
+    base_path: str,
+    dir_path: str,
+    reason: str,
+    limits: dict[str, int],
+    budget: _Budget,
+    max_files: int = 20,
+) -> list[str]:
+    """Read all .md files in a directory, applying the same per-file and
+    total caps as a single-file JSONL entry."""
+    full_path = os.path.join(base_path, dir_path)
+    if not os.path.exists(full_path) or not os.path.isdir(full_path):
+        return []
+
+    blocks: list[str] = []
+    try:
+        md_files = sorted(
+            f
+            for f in os.listdir(full_path)
+            if f.endswith(".md") and os.path.isfile(os.path.join(full_path, f))
+        )
+        for filename in md_files[:max_files]:
+            relative_path = os.path.join(dir_path, filename)
+            block = _materialize_file(base_path, relative_path, reason, limits, budget)
+            if block:
+                blocks.append(block)
+    except Exception:
+        pass
+
+    return blocks
+
+
 def read_jsonl_entries(base_path: str, jsonl_path: str) -> list[dict]:
-    """Keep the historical probe surface while using the shared parser."""
-    scripts_dir = Path(base_path) / DIR_WORKFLOW / "scripts"
-    if str(scripts_dir) not in sys.path:
-        sys.path.insert(0, str(scripts_dir))
-    from common.context_projection import parse_context_manifest  # type: ignore[import-not-found]
+    """
+    Parse all file/directory entries referenced in a jsonl context file.
+
+    Schema:
+        {"file": "path/to/file.md", "reason": "..."}
+        {"file": "path/to/dir/", "type": "directory", "reason": "..."}
+        {"_example": "..."}          # legacy placeholder — skipped (no `file` field)
 
-    entries, _, exists = parse_context_manifest(Path(base_path) / jsonl_path)
-    if not exists:
+    Rows without a ``file`` field (e.g. the placeholder line older Trellis
+    versions wrote at ``task.py create`` time) are skipped silently. If the
+    resulting entry list is empty, a stderr warning is emitted so the operator
+    can debug missing context.
+
+    Returns:
+        [{"file": path, "type": "file" | "directory", "reason": reason}, ...]
+    """
+    full_path = os.path.join(base_path, jsonl_path)
+    if not os.path.exists(full_path):
         print(
             f"[inject-subagent-context] WARN: {jsonl_path} not found — "
-            "sub-agent will receive only task artifacts",
+            f"sub-agent will receive only task artifacts",
             file=sys.stderr,
         )
-    elif not entries:
+        return []
+
+    entries: list[dict] = []
+    saw_real_entry = False
+    try:
+        with open(full_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    item = json.loads(line)
+                    file_path = item.get("file") or item.get("path")
+
+                    if not file_path:
+                        # Seed / comment row — skip silently
+                        continue
+
+                    saw_real_entry = True
+                    entries.append(
+                        {
+                            "file": file_path,
+                            "type": item.get("type", "file"),
+                            "reason": item.get("reason") or "-",
+                        }
+                    )
+                except json.JSONDecodeError:
+                    continue
+    except Exception:
+        pass
+
+    if not saw_real_entry:
         print(
             f"[inject-subagent-context] WARN: {jsonl_path} has no curated "
-            "entries (only seed / empty) — sub-agent will receive only "
-            "task artifacts. See workflow.md planning artifact guidance.",
+            f"entries (only seed / empty) — sub-agent will receive only "
+            f"task artifacts. See workflow.md planning artifact guidance.",
             file=sys.stderr,
         )
-    return [
-        {"file": entry.path, "type": entry.entry_type, "reason": entry.reason}
-        for entry in entries
-    ]
+
+    return entries
+
+
+def _materialize_jsonl_entries(
+    base_path: str, jsonl_path: str, limits: dict[str, int], budget: _Budget
+) -> list[str]:
+    """Materialize every entry in a jsonl context file into context blocks,
+    applying per-file and total budget caps."""
+    blocks: list[str] = []
+    for entry in read_jsonl_entries(base_path, jsonl_path):
+        if entry["type"] == "directory":
+            blocks.extend(
+                _materialize_directory(
+                    base_path, entry["file"], entry["reason"], limits, budget
+                )
+            )
+        else:
+            block = _materialize_file(
+                base_path, entry["file"], entry["reason"], limits, budget
+            )
+            if block:
+                blocks.append(block)
+    return blocks
+
+
+def get_agent_context(
+    repo_root: str,
+    task_dir: str,
+    agent_type: str,
+    limits: dict[str, int],
+    budget: _Budget,
+) -> str:
+    """
+    Get context from {agent_type}.jsonl for the specified agent.
+    Only reads implement.jsonl or check.jsonl (the two JSONL files the task system creates).
+    """
+    agent_jsonl = f"{task_dir}/{agent_type}.jsonl"
+    blocks = _materialize_jsonl_entries(repo_root, agent_jsonl, limits, budget)
+    if not blocks:
+        # Zero curated context reaches the model silently otherwise — the
+        # stderr WARN above never enters any session (#573). Put the fact in
+        # the prompt itself so the sub-agent compensates instead of assuming
+        # the spec context was complete.
+        return (
+            f"[Trellis] {agent_jsonl} has no curated entries, so no spec/research "
+            "context was injected. Before working, read the guidelines relevant "
+            "to the code you will touch under .trellis/spec/, and treat the task "
+            "artifacts below as the only prepared context."
+        )
+    return "\n\n".join(blocks)
+
+
+def _materialize_artifact(
+    base_path: str,
+    file_path: str,
+    header_label: str,
+    reason: str,
+    limits: dict[str, int],
+    budget: _Budget,
+) -> str | None:
+    """Read a task artifact (prd/design/implement.md), apply the per-artifact
+    cap, then budget it."""
+    data = _read_file_bytes(base_path, file_path)
+    if data is None:
+        return None
+
+    size = len(data)
+    cap = limits["max_artifact_bytes"]
+    truncated_bytes = truncate_utf8(data, cap)
+    content = truncated_bytes.decode("utf-8", errors="replace")
+    if len(truncated_bytes) < size:
+        content += _truncate_notice(file_path, cap)
+
+    return _budgeted_block(budget, header_label, file_path, content, reason, size)
 
 
 def get_implement_context(repo_root: str, task_dir: str) -> str:
-    """Complete Python context for an Implement subagent."""
-    return _project_context(repo_root, task_dir, "implement").text
+    """
+    Complete context for Implement Agent
+
+    Read order:
+    1. All files in implement.jsonl (spec/research manifests)
+    2. prd.md (requirements)
+    3. design.md if present (technical design)
+    4. implement.md if present (execution plan)
+    """
+    limits = _get_limits(repo_root)
+    budget = _Budget(limits["max_total_bytes"])
+    context_parts = []
+
+    # 1. Read implement.jsonl
+    base_context = get_agent_context(repo_root, task_dir, "implement", limits, budget)
+    if base_context:
+        context_parts.append(base_context)
+
+    # 2. Requirements document
+    prd_block = _materialize_artifact(
+        repo_root,
+        f"{task_dir}/prd.md",
+        f"{task_dir}/prd.md (Requirements)",
+        "Requirements document",
+        limits,
+        budget,
+    )
+    if prd_block:
+        context_parts.append(prd_block)
+
+    # 3. Technical design for complex tasks
+    design_block = _materialize_artifact(
+        repo_root,
+        f"{task_dir}/design.md",
+        f"{task_dir}/design.md (Technical Design)",
+        "Technical design document",
+        limits,
+        budget,
+    )
+    if design_block:
+        context_parts.append(design_block)
+
+    # 4. Execution plan for complex tasks
+    implement_plan_block = _materialize_artifact(
+        repo_root,
+        f"{task_dir}/implement.md",
+        f"{task_dir}/implement.md (Execution Plan)",
+        "Execution plan document",
+        limits,
+        budget,
+    )
+    if implement_plan_block:
+        context_parts.append(implement_plan_block)
+
+    return "\n\n".join(context_parts)
 
 
 def get_check_context(repo_root: str, task_dir: str) -> str:
-    """Complete Python context for a Check subagent."""
-    return _project_context(repo_root, task_dir, "check").text
+    """
+    Context for Check Agent: check.jsonl + task artifacts.
+    """
+    limits = _get_limits(repo_root)
+    budget = _Budget(limits["max_total_bytes"])
+    context_parts = []
+
+    base_context = get_agent_context(repo_root, task_dir, "check", limits, budget)
+    if base_context:
+        context_parts.append(base_context)
+
+    prd_block = _materialize_artifact(
+        repo_root,
+        f"{task_dir}/prd.md",
+        f"{task_dir}/prd.md (Requirements)",
+        "Requirements document",
+        limits,
+        budget,
+    )
+    if prd_block:
+        context_parts.append(prd_block)
+
+    design_block = _materialize_artifact(
+        repo_root,
+        f"{task_dir}/design.md",
+        f"{task_dir}/design.md (Technical Design)",
+        "Technical design document",
+        limits,
+        budget,
+    )
+    if design_block:
+        context_parts.append(design_block)
+
+    implement_plan_block = _materialize_artifact(
+        repo_root,
+        f"{task_dir}/implement.md",
+        f"{task_dir}/implement.md (Execution Plan)",
+        "Execution plan document",
+        limits,
+        budget,
+    )
+    if implement_plan_block:
+        context_parts.append(implement_plan_block)
+
+    return "\n\n".join(context_parts)
 
 
 def get_finish_context(repo_root: str, task_dir: str) -> str:
-    """Finish reuses the Check projection."""
+    """
+    Context for Finish phase: reuses check.jsonl + prd.md
+    (Finish is a final check, same context source.)
+    """
     return get_check_context(repo_root, task_dir)
 
 
+
 def build_implement_prompt(original_prompt: str, context: str) -> str:
     """Build complete prompt for Implement"""
     return f"""<!-- trellis-hook-injected -->
@@ -774,31 +1157,26 @@ def main():
     # 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. A project can have
-    # an older stamped `.trellis/scripts` tree while its platform Hook is
-    # already refreshed; preserve the Hook's fail-open spawn contract there.
-    try:
-        if subagent_type == AGENT_IMPLEMENT:
-            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 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, 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, task_dir)
-                new_prompt = build_check_prompt(original_prompt, context)
-        elif subagent_type == AGENT_RESEARCH:
-            # Research can work without task directory
-            context = get_research_context(repo_root, task_dir)
-            new_prompt = build_research_prompt(original_prompt, context)
+    # Get context and build prompt based on subagent type
+    if subagent_type == AGENT_IMPLEMENT:
+        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 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, task_dir)
+            new_prompt = build_finish_prompt(original_prompt, context)
         else:
-            sys.exit(0)
-    except Exception:
+            # Regular check phase: use check context (full specs for self-fix loop)
+            context = get_check_context(repo_root, task_dir)
+            new_prompt = build_check_prompt(original_prompt, context)
+    elif subagent_type == AGENT_RESEARCH:
+        # 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)
 
     if not context: