@mindfoldhq/trellis 0.6.7 → 0.6.9

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

@@ -20,6 +20,9 @@ Supported platforms:
 - droid: Factory Droid (commands-based)
 - pi: Pi Agent (extension-backed)
 - trae: Trae IDE (IDE-only, hooks-based)
+- omp: Oh My Pi
+- grok: Grok Build (pull-based skills/agents; no hook context injection)
+- kimi: Kimi Code (pull-based skills; commands delivered as skills; no hook context injection)
 
 Usage:
     from common.cli_adapter import CLIAdapter
@@ -56,6 +59,8 @@ Platform = Literal[
     "pi",
     "trae",
     "omp",
+    "grok",
+    "kimi",
 ]
 
 
@@ -134,6 +139,10 @@ class CLIAdapter:
             return ".trae"
         elif self.platform == "omp":
             return ".omp"
+        elif self.platform == "grok":
+            return ".grok"
+        elif self.platform == "kimi":
+            return ".kimi-code"
         else:
             return ".claude"
 
@@ -191,7 +200,8 @@ class CLIAdapter:
                     filename = filename[:-3]
                 return prompts_dir / f"trellis-{filename}.md"
             return prompts_dir / Path(*parts)
-        if self.platform == "omp":
+        # OMP and Grok: flat slash commands under .{platform}/commands/trellis-<name>.md
+        if self.platform in ("omp", "grok"):
             commands_dir = self.get_config_dir(project_root) / "commands"
             if not parts:
                 return commands_dir
@@ -202,6 +212,17 @@ class CLIAdapter:
                 return commands_dir / f"trellis-{filename}.md"
             return commands_dir / Path(*parts)
 
+        # Kimi: commands are skills under .kimi-code/skills/trellis-<name>/SKILL.md
+        if self.platform == "kimi":
+            skills_dir = self.get_config_dir(project_root) / "skills"
+            if not parts:
+                return skills_dir
+            if len(parts) >= 2 and parts[0] == "trellis":
+                filename = parts[-1]
+                if filename.endswith(".md"):
+                    filename = filename[:-3]
+                return skills_dir / f"trellis-{filename}" / "SKILL.md"
+            return skills_dir / Path(*parts)
 
         if self.platform == "devin":
             workflow_dir = self.get_config_dir(project_root) / "workflows"
@@ -286,8 +307,10 @@ class CLIAdapter:
             return f".factory/commands/trellis/{name}.md"
         elif self.platform == "pi":
             return f".pi/prompts/trellis-{name}.md"
-        elif self.platform == "omp":
-            return f".omp/commands/trellis-{name}.md"
+        elif self.platform in ("omp", "grok"):
+            return f"{self.config_dir_name}/commands/trellis-{name}.md"
+        elif self.platform == "kimi":
+            return f".kimi-code/skills/trellis-{name}/SKILL.md"
         else:
             return f"{self.config_dir_name}/commands/trellis/{name}.md"
 
@@ -329,6 +352,10 @@ class CLIAdapter:
             return {}
         elif self.platform == "omp":
             return {}
+        elif self.platform == "grok":
+            return {}
+        elif self.platform == "kimi":
+            return {}
         else:
             return {"CLAUDE_NON_INTERACTIVE": "1"}
 
@@ -422,6 +449,13 @@ class CLIAdapter:
             raise ValueError(
                 "OMP uses native task tool for agent runs; CLI agent run is not supported."
             )
+        elif self.platform == "grok":
+            # Headless single-prompt; sub-agents use in-process spawn_subagent.
+            cmd = ["grok", "-p", prompt, "--yolo"]
+        elif self.platform == "kimi":
+            # Headless single-prompt with auto-approval; sub-agents are the
+            # built-in coder/explore/plan agents dispatched in-session.
+            cmd = ["kimi", "-p", prompt, "--yolo"]
 
         else:  # claude
             cmd = ["claude", "-p"]
@@ -496,6 +530,10 @@ class CLIAdapter:
             raise ValueError(
                 "OMP uses native task tool for agent runs; CLI resume is not supported."
             )
+        elif self.platform == "grok":
+            return ["grok", "-c"]
+        elif self.platform == "kimi":
+            return ["kimi", "--session", session_id]
         else:
             return ["claude", "--resume", session_id]
 
@@ -574,6 +612,10 @@ class CLIAdapter:
             return "trae"
         elif self.platform == "omp":
             return "omp"
+        elif self.platform == "grok":
+            return "grok"
+        elif self.platform == "kimi":
+            return "kimi"
         else:
             return "claude"
 
@@ -584,7 +626,15 @@ class CLIAdapter:
         Claude Code, OpenCode, iFlow, and Codex support CLI agent execution.
         Cursor is IDE-only and doesn't support CLI agents.
         """
-        return self.platform in ("claude", "opencode", "iflow", "codex", "pi")
+        return self.platform in (
+            "claude",
+            "opencode",
+            "iflow",
+            "codex",
+            "pi",
+            "grok",
+            "kimi",
+        )
 
     @property
     def requires_agent_definition_file(self) -> bool:
@@ -671,9 +721,11 @@ def get_cli_adapter(platform: str = "claude") -> CLIAdapter:
         "pi",
         "trae",
         "omp",
+        "grok",
+        "kimi",
     ):
         raise ValueError(
-            f"Unsupported platform: {platform} (must be 'claude', 'opencode', 'cursor', 'iflow', 'codex', 'kilo', 'kiro', 'gemini', 'antigravity', 'devin', 'qoder', 'codebuddy', 'copilot', 'droid', 'pi', 'trae', or 'omp')"
+            f"Unsupported platform: {platform} (must be 'claude', 'opencode', 'cursor', 'iflow', 'codex', 'kilo', 'kiro', 'gemini', 'antigravity', 'devin', 'qoder', 'codebuddy', 'copilot', 'droid', 'pi', 'trae', 'omp', 'grok', or 'kimi')"
         )
 
     return CLIAdapter(platform=platform)  # type: ignore
@@ -698,6 +750,8 @@ _ALL_PLATFORM_CONFIG_DIRS = (
     ".pi",
     ".trae",
     ".omp",
+    ".grok",
+    ".kimi-code",
 )
 """Platform-specific config directory names used by detect_platform exclusion
 checks. `.agents/skills/` is NOT listed here: it is a shared cross-platform
@@ -768,6 +822,8 @@ def detect_platform(project_root: Path) -> Platform:
         "pi",
         "trae",
         "omp",
+        "grok",
+        "kimi",
     ):
         return env_platform  # type: ignore
 
@@ -852,6 +908,14 @@ def detect_platform(project_root: Path) -> Platform:
     if (project_root / ".omp").is_dir():
         return "omp"
 
+    # Check for .grok directory (Grok Build-specific)
+    if (project_root / ".grok").is_dir():
+        return "grok"
+
+    # Check for .kimi-code directory (Kimi Code-specific)
+    if (project_root / ".kimi-code").is_dir():
+        return "kimi"
+
     # Fallback: checkout only has the Codex shared-skills layer
     # (.agents/skills/trellis-* dirs) and no explicit platform config dir.
     # Happens on fresh clones where .codex/ is gitignored/absent but the

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

@@ -117,11 +117,12 @@ def _parse_yaml_block(
             key, _, value = stripped.partition(":")
             key = key.strip()
             value = _strip_inline_comment(value).strip()
+            was_quoted = len(value) >= 2 and value[0] == value[-1] and value[0] in ('"', "'")
             value = _unquote(value)
             current_list = None
 
-            if value:
-                # key: value
+            if value or was_quoted:
+                # key: value (an explicit quoted "" is a value, not "no value")
                 target[key] = value
                 i += 1
             else:
@@ -167,7 +168,7 @@ def _next_content_line(lines: list[str], start: int) -> tuple[int, str]:
 DEFAULT_SESSION_COMMIT_MESSAGE = "chore: record journal"
 DEFAULT_MAX_JOURNAL_LINES = 2000
 DEFAULT_SESSION_AUTO_COMMIT = True
-DEFAULT_CODEX_DISPATCH_MODE = "inline"
+DEFAULT_CODEX_DISPATCH_MODE = "auto"
 
 CONFIG_FILE = "config.yaml"
 
@@ -247,8 +248,14 @@ def get_session_auto_commit(repo_root: Path | None = None) -> bool:
 def get_codex_dispatch_mode(repo_root: Path | None = None) -> str:
     """Return Codex dispatch mode.
 
-    Default is ``inline``. ``sub-agent`` is an explicit opt-in because Codex
-    sub-agents do not inherit the parent session context.
+    Default is ``auto``, which dispatches Trellis sub-agents and uses native
+    context injection with a child-side fallback. ``inline`` is an explicit
+    opt-out. ``sub-agent`` remains a backwards-compatible alias for ``auto``.
+
+    Invalid explicit configuration falls back to ``inline`` rather than
+    unexpectedly dispatching a sub-agent. This CLI-facing parser is the only
+    place that emits a warning for invalid values; hook readers fail safely
+    without producing per-turn warning noise.
     """
     config = _load_config(repo_root)
     codex = config.get("codex")
@@ -256,20 +263,108 @@ def get_codex_dispatch_mode(repo_root: Path | None = None) -> str:
         return DEFAULT_CODEX_DISPATCH_MODE
     if not isinstance(codex, dict):
         print(
-            f"[WARN] invalid codex config: {codex!r}; using {DEFAULT_CODEX_DISPATCH_MODE}",
+            f"[WARN] invalid codex config: {codex!r}; using inline",
             file=sys.stderr,
         )
-        return DEFAULT_CODEX_DISPATCH_MODE
+        return "inline"
 
     raw = codex.get("dispatch_mode", DEFAULT_CODEX_DISPATCH_MODE)
     mode = str(raw).strip().lower()
-    if mode in ("inline", "sub-agent"):
+    if mode in ("auto", "inline"):
         return mode
+    if mode == "sub-agent":
+        return "auto"
     print(
-        f"[WARN] invalid codex.dispatch_mode value: {raw!r}; using {DEFAULT_CODEX_DISPATCH_MODE}",
+        f"[WARN] invalid codex.dispatch_mode value: {raw!r}; using inline",
         file=sys.stderr,
     )
-    return DEFAULT_CODEX_DISPATCH_MODE
+    return "inline"
+
+
+DEFAULT_CONTEXT_INJECTION_MAX_FILE_BYTES = 32768
+DEFAULT_CONTEXT_INJECTION_MAX_ARTIFACT_BYTES = 65536
+DEFAULT_CONTEXT_INJECTION_MAX_TOTAL_BYTES = 131072
+
+
+def get_context_injection_limits(repo_root: Path | None = None) -> dict[str, int]:
+    """Return sub-agent context injection byte limits.
+
+    Reads the ``context_injection:`` section of ``.trellis/config.yaml``:
+
+        context_injection:
+          max_file_bytes: 32768
+          max_artifact_bytes: 65536
+          max_total_bytes: 131072
+
+    ``0`` disables the corresponding limit. Missing keys use their default;
+    invalid (non-int or negative) values fall back to the default for that
+    key with a stderr warning.
+    """
+    defaults = {
+        "max_file_bytes": DEFAULT_CONTEXT_INJECTION_MAX_FILE_BYTES,
+        "max_artifact_bytes": DEFAULT_CONTEXT_INJECTION_MAX_ARTIFACT_BYTES,
+        "max_total_bytes": DEFAULT_CONTEXT_INJECTION_MAX_TOTAL_BYTES,
+    }
+
+    config = _load_config(repo_root)
+    section = config.get("context_injection")
+    if not isinstance(section, dict):
+        return defaults
+
+    result = dict(defaults)
+    for key, default_value in defaults.items():
+        if key not in section:
+            continue
+        raw = section[key]
+        try:
+            value = int(raw)
+        except (TypeError, ValueError):
+            print(
+                f"[WARN] invalid context_injection.{key} value: {raw!r}; "
+                f"using default {default_value}",
+                file=sys.stderr,
+            )
+            continue
+        if value < 0:
+            print(
+                f"[WARN] invalid context_injection.{key} value: {raw!r}; "
+                f"using default {default_value}",
+                file=sys.stderr,
+            )
+            continue
+        result[key] = value
+
+    return result
+
+
+DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD = "no-trellis"
+
+
+def get_prompt_injection_config(repo_root: Path | None = None) -> dict[str, str]:
+    """Return per-turn prompt injection config.
+
+    Reads the ``prompt_injection:`` section of ``.trellis/config.yaml``:
+
+        prompt_injection:
+          skip_keyword: "no-trellis"   # "" disables the escape hatch entirely
+
+    ``skip_keyword`` is the word-boundary, case-insensitive keyword that, when
+    present in the user's prompt, makes the per-turn workflow-state injection
+    emit nothing for that turn. Defaults to ``"no-trellis"``. A non-string
+    value falls back to the default.
+    """
+    defaults = {"skip_keyword": DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD}
+
+    config = _load_config(repo_root)
+    section = config.get("prompt_injection")
+    if not isinstance(section, dict):
+        return defaults
+
+    result = dict(defaults)
+    raw = section.get("skip_keyword", DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD)
+    if isinstance(raw, str):
+        result["skip_keyword"] = raw
+    return result
 
 
 def get_hooks(event: str, repo_root: Path | None = None) -> list[str]:

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

@@ -29,3 +29,39 @@ def run_git(args: list[str], cwd: Path | None = None) -> tuple[int, str, str]:
         return result.returncode, result.stdout, result.stderr
     except Exception as e:
         return 1, "", str(e)
+
+
+def resolve_default_branch(repo_root: Path) -> str | None:
+    """Resolve the repository's default branch (origin/HEAD target).
+
+    Tries the local `refs/remotes/origin/HEAD` symbolic ref first (no
+    network access), then falls back to `git remote show origin` (which
+    may hit the network but also repairs a missing/stale symbolic-ref).
+    Returns None when neither resolves, so callers can fall back to their
+    own pre-existing behavior.
+    """
+    rc, out, _ = run_git(["symbolic-ref", "refs/remotes/origin/HEAD"], cwd=repo_root)
+    if rc == 0 and out.strip():
+        return out.strip().rsplit("/", 1)[-1]
+
+    rc, out, _ = run_git(["remote", "show", "origin"], cwd=repo_root)
+    if rc == 0:
+        for line in out.splitlines():
+            line = line.strip()
+            if line.startswith("HEAD branch:"):
+                branch = line.split(":", 1)[1].strip()
+                if branch and branch != "(unknown)":
+                    return branch
+
+    return None
+
+
+def branch_exists_locally(branch: str, repo_root: Path) -> bool:
+    """Check whether a local branch ref exists in the repository."""
+    if not branch:
+        return False
+    rc, _, _ = run_git(
+        ["rev-parse", "--verify", "--quiet", f"refs/heads/{branch}"],
+        cwd=repo_root,
+    )
+    return rc == 0

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

@@ -39,16 +39,23 @@ def write_json(path: Path, data: dict) -> bool:
         fd, tmp = tempfile.mkstemp(
             dir=str(path.parent), prefix=f".{path.name}.", suffix=".tmp"
         )
+    except OSError:
+        return False
+
+    try:
         try:
-            with os.fdopen(fd, "w", encoding="utf-8") as f:
-                f.write(payload)
-            os.replace(tmp, path)
-        except BaseException:
-            try:
-                os.unlink(tmp)
-            except OSError:
-                pass
+            f = os.fdopen(fd, "w", encoding="utf-8")
+        except OSError:
+            # fdopen never took ownership of fd; close it ourselves.
+            os.close(fd)
             raise
+        with f:
+            f.write(payload)
+        os.replace(tmp, path)
         return True
-    except (OSError, IOError):
+    except OSError:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
         return False

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

@@ -21,10 +21,36 @@ import argparse
 import json
 from pathlib import Path
 
+from .config import get_context_injection_limits
+from .git import branch_exists_locally
+from .io import read_json
 from .log import Colors, colored
-from .paths import get_repo_root
+from .paths import FILE_TASK_JSON, get_repo_root
 from .task_utils import resolve_task_dir
 
+# Extensions that look like code rather than spec/research docs. Entries with
+# one of these extensions outside .trellis/spec/, docs/docs-site, or the
+# task's own directory get a hygiene warning in `task.py validate` — the
+# reader is a sub-agent, not a human, so code paths belong in the diff the
+# agent reads itself, not in implement.jsonl / check.jsonl.
+_CODE_FILE_EXTENSIONS = {
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".rb",
+    ".c",
+    ".cc",
+    ".cpp",
+    ".h",
+}
+
 
 # =============================================================================
 # Command: add-context
@@ -97,10 +123,26 @@ def cmd_validate(args: argparse.Namespace) -> int:
     print(f"Target dir: {target_dir}")
     print()
 
+    # Warn (don't fail validation) when the recorded branch is stale — it
+    # was likely already merged and deleted (#399 item 2).
+    task_json_path = target_dir / FILE_TASK_JSON
+    if task_json_path.is_file():
+        task_data = read_json(task_json_path)
+        stored_branch = task_data.get("branch") if task_data else None
+        if stored_branch and not branch_exists_locally(stored_branch, repo_root):
+            print(
+                colored(
+                    f"Warning: recorded branch '{stored_branch}' no longer exists locally "
+                    "(likely merged and deleted).",
+                    Colors.YELLOW,
+                )
+            )
+            print()
+
     total_errors = 0
     for jsonl_name in ["implement.jsonl", "check.jsonl"]:
         jsonl_file = target_dir / jsonl_name
-        errors = _validate_jsonl(jsonl_file, repo_root)
+        errors = _validate_jsonl(jsonl_file, repo_root, target_dir)
         total_errors += errors
 
     print()
@@ -112,11 +154,33 @@ def cmd_validate(args: argparse.Namespace) -> int:
         return 1
 
 
-def _validate_jsonl(jsonl_file: Path, repo_root: Path) -> int:
+def _is_exempt_from_code_file_warning(file_path: str, task_rel: str) -> bool:
+    """Whether a jsonl entry path is exempt from the code-file hygiene warning.
+
+    Exempt: spec docs (``.trellis/spec/``), documentation (``docs``,
+    ``docs-site``), and the task's own directory (execution plans, generated
+    artifacts, etc. legitimately live there).
+    """
+    posix_path = file_path.replace("\\", "/").lstrip("/")
+    exempt_prefixes = (".trellis/spec/", "docs/", "docs-site/")
+    if posix_path.startswith(exempt_prefixes):
+        return True
+    if task_rel and (posix_path == task_rel or posix_path.startswith(f"{task_rel}/")):
+        return True
+    return False
+
+
+def _validate_jsonl(jsonl_file: Path, repo_root: Path, task_dir: Path | None = None) -> int:
     """Validate a single JSONL file.
 
     Seed rows (no ``file`` field — typically ``{"_example": "..."}``) are
     skipped silently; they are self-describing comments, not real entries.
+
+    Beyond hard errors (missing file/dir, invalid JSON), this also prints
+    non-blocking hygiene warnings (never counted in ``errors``, never change
+    the exit code): entries that look like code files rather than
+    spec/research docs, and entries whose file size exceeds the configured
+    sub-agent context injection cap (``context_injection.max_file_bytes``).
     """
     file_name = jsonl_file.name
     errors = 0
@@ -125,6 +189,15 @@ def _validate_jsonl(jsonl_file: Path, repo_root: Path) -> int:
         print(f"  {colored(f'{file_name}: not found (skipped)', Colors.YELLOW)}")
         return 0
 
+    task_rel = ""
+    if task_dir is not None:
+        try:
+            task_rel = task_dir.resolve().relative_to(repo_root.resolve()).as_posix()
+        except ValueError:
+            task_rel = ""
+
+    max_file_bytes = get_context_injection_limits(repo_root).get("max_file_bytes", 0)
+
     line_num = 0
     real_entries = 0
     for line in jsonl_file.read_text(encoding="utf-8").splitlines():
@@ -152,10 +225,31 @@ def _validate_jsonl(jsonl_file: Path, repo_root: Path) -> int:
             if not full_path.is_dir():
                 print(f"  {colored(f'{file_name}:{line_num}: Directory not found: {file_path}', Colors.RED)}")
                 errors += 1
-        else:
-            if not full_path.is_file():
-                print(f"  {colored(f'{file_name}:{line_num}: File not found: {file_path}', Colors.RED)}")
-                errors += 1
+            continue
+
+        if not full_path.is_file():
+            print(f"  {colored(f'{file_name}:{line_num}: File not found: {file_path}', Colors.RED)}")
+            errors += 1
+            continue
+
+        extension = Path(file_path).suffix.lower()
+        if extension in _CODE_FILE_EXTENSIONS and not _is_exempt_from_code_file_warning(
+            file_path, task_rel
+        ):
+            print(
+                f"  {colored(f'{file_name}:{line_num}: Warning: {file_path} looks like a code file — '
+                             'implement/check.jsonl should reference spec/research docs; '
+                             'agents read code themselves', Colors.YELLOW)}"
+            )
+
+        if max_file_bytes:
+            size = full_path.stat().st_size
+            if size > max_file_bytes:
+                print(
+                    f"  {colored(f'{file_name}:{line_num}: Warning: {file_path} is {size} bytes, '
+                                 f'exceeds context_injection.max_file_bytes ({max_file_bytes}); '
+                                 'injection will truncate it', Colors.YELLOW)}"
+                )
 
     if errors == 0:
         print(f"  {colored(f'{file_name}: ✓ ({real_entries} entries)', Colors.GREEN)}")