abhigyanpatwari/GitNexus · error · SandboxError

Compound Engineering plugin path exceeds the byte limit: {re

Error message

Compound Engineering plugin path exceeds the byte limit: {relative_text}

What it means

Path-length guard in _build_ce_plugin_snapshot. A plugin file's POSIX-relative path, encoded as UTF-8, must be at most MAX_CE_PLUGIN_PATH_BYTES (1024 bytes). Deeply nested trees or paths heavy with multibyte characters are rejected before they are even read, to keep manifest entries and the eventual mount bounded and portable.

Source

Thrown at eval/workflow_bench/runtime_mounts.py:428

        return
    for directory, _, files in os.walk(root):
        for name in files:
            (Path(directory) / name).chmod(0o600)
        Path(directory).chmod(0o700)
    shutil.rmtree(root)


def _build_ce_plugin_snapshot(config: CePluginConfig, destination_parent: Path) -> CePluginSnapshot:
    parent = _validated_runtime_root(destination_parent, label="CE plugin snapshot parent")
    root = Path(tempfile.mkdtemp(prefix="wfbench-ce-plugin-", dir=parent))
    root.chmod(0o700)
    entries: list[dict[str, Any]] = []
    total_bytes = 0
    try:
        for relative, source in _plugin_files(config.source):
            relative_text = relative.as_posix()
            if len(relative_text.encode()) > MAX_CE_PLUGIN_PATH_BYTES:
                raise SandboxError(f"Compound Engineering plugin path exceeds the byte limit: {relative_text}")
            if len(entries) >= MAX_CE_PLUGIN_FILES:
                raise SandboxError("Compound Engineering plugin exceeds the file-count limit")
            payload, executable = _bounded_plugin_bytes(source)
            total_bytes += len(payload)
            if total_bytes > MAX_CE_PLUGIN_TOTAL_BYTES:
                raise SandboxError("Compound Engineering plugin exceeds the total byte limit")
            _write_snapshot_file(
                root / Path(*relative.parts),
                payload,
                executable=executable,
            )
            entries.append(
                {
                    "path": relative_text,
                    "sha256": hashlib.sha256(payload).hexdigest(),
                    "size": len(payload),
                    "executable": executable,
                }

View on GitHub (pinned to d540b00184)

Solutions

Find long paths: 'find <plugin_dir> -type f | awk '{print length, $0}' | sort -rn | head' and relocate/shorten the worst offenders.
Flatten deeply nested vendored trees; keep only the slices the skill imports.
Rename unicode-heavy descriptive files to short ASCII names.
Reduce directory nesting by collapsing unnecessary intermediate folders.

Example fix

# before
skills/ce-plan/assets/references/very/deep/nested/path/to/some-long-descriptive-filename-中文.md
# after
skills/ce-plan/assets/refs/some-filename.md

Defensive patterns

Strategy: validation

Validate before calling

from pathlib import Path

MAX_BYTES = 1024
plugin = Path("ce-plugin")
allowed = ("skills", "scripts", "assets", ".claude-plugin")
over = []
for base in allowed:
    d = plugin / base
    if not d.exists():
        continue
    for p in d.rglob("*"):
        if p.is_file():
            rel = p.relative_to(plugin).as_posix()
            if len(rel.encode()) > MAX_BYTES:
                over.append(rel)
if over:
    raise SystemExit(f"plugin paths over 1024 bytes: {over}")

Type guard

MAX_CE_PLUGIN_PATH_BYTES = 1024

def path_within_bound(relative_posix: str) -> bool:
    return len(relative_posix.encode()) <= MAX_CE_PLUGIN_PATH_BYTES

Try / catch

try:
    snapshot = _build_ce_plugin_snapshot(config, destination_parent)
except SandboxError as exc:
    if "path exceeds the byte limit" in str(exc):
        log.error("plugin path > 1024 UTF-8 bytes; flatten/rename")
    raise

Prevention

Keep plugin paths short and ASCII where possible.
Avoid deep node_modules-style nesting inside the plugin.
CI gate: flag any file whose slash-relative path exceeds 1024 UTF-8 bytes.

When it happens

Trigger: Any entry under skills/scripts/assets whose slash-relative path exceeds 1024 UTF-8 bytes. Typical producers: deeply nested node_modules-like dedup, generated/suffixed artifact names, CJK/emoji-heavy descriptive skill names.

Common situations: A generator emitted long hashed filenames; a vendored dependency kept its deep node_modules layout; non-ASCII documentation filenames with descriptive titles.

Related errors

AI-assisted analysis of abhigyanpatwari/GitNexus@d540b00184 (2026-08-12). Data as JSON: /api/errors/cd11c24fce536992. Report an issue: GitHub.