@pennixrv/trellis 0.7.0-beta.9 → 0.7.1-beta.0

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

@@ -4,7 +4,7 @@ Safe git-add helpers for Trellis-owned paths.
 Why this module exists
 ----------------------
 A real user incident: a project's `.gitignore` listed `.trellis/` (company-wide
-template / personal habit). When `add_session.py` and `task.py archive` ran
+template / personal habit). When `add_session.py` ran
 their auto-commit and `git add` failed with `ignored by .gitignore`, the AI
 agent driving the workflow "fixed" it by retrying with
 `git add -f .trellis/` — which fan-out-included every ignored subtree
@@ -13,8 +13,8 @@ agent driving the workflow "fixed" it by retrying with
 
 Design
 ------
-- Scripts only stage SPECIFIC product paths (journal files, index.md, the
-  current task dir, the archive dir). Never the whole `.trellis/` tree.
+- Scripts only stage SPECIFIC product paths (journal files, index.md, and the
+  current task dir). Never the whole `.trellis/` tree.
 - If plain `git add <specific>` fails with "ignored by", DO NOT retry with
   ``-f``. The presence of `.trellis/` in `.gitignore` is treated as user
   intent ("keep .trellis/ local-only"). The script warns and skips the
@@ -37,7 +37,6 @@ from pathlib import Path
 
 from .git import run_git, run_git_retry_index_lock
 from .paths import (
-    DIR_ARCHIVE,
     DIR_TASKS,
     DIR_WORKFLOW,
     DIR_WORKSPACE,
@@ -72,8 +71,7 @@ def safe_trellis_paths_to_add(
       - .trellis/workspace/<developer>/journal-*.md
       - .trellis/workspace/<developer>/index.md
       - .trellis/tasks/<task_name>/   (ONLY the current task dir when
-        ``task_name`` is passed; plus its archive location if the task
-        already lives under archive/)
+        ``task_name`` is passed)
 
     Excluded (intentionally — these must not be staged):
       - .trellis/.backup-*, .trellis/worktrees/,
@@ -82,12 +80,11 @@ def safe_trellis_paths_to_add(
     Scope contract (see #303 / break-loop analysis): when ``task_name`` is
     passed, the task segment stages ONLY that task directory — it never walks
     ``tasks_dir.iterdir()`` over all active tasks. This mirrors
-    :func:`safe_archive_paths_to_add` and prevents dirty changes in OTHER
-    parallel-window task dirs from being bundled into the session auto-commit.
+    and prevents dirty changes in OTHER parallel-window task dirs from being
+    bundled into the session auto-commit.
 
-    Backwards-compat: with no ``task_name``, the function walks every active
-    task directory (+ the archive subtree) the old wide way. New callers
-    should always pass ``task_name``.
+    With no ``task_name``, the function walks every direct task directory.
+    New callers should always pass ``task_name``.
     """
     paths: list[str] = []
 
@@ -112,90 +109,20 @@ def safe_trellis_paths_to_add(
         return paths
 
     if task_name is not None:
-        # Narrow scope — ONLY the current task directory (active or archived).
+        # Narrow scope — ONLY the current task directory.
         # Never iterdir() all tasks: parallel-window dirty task dirs must not
         # leak into the session auto-commit.
         active_task = tasks_dir / task_name
         if active_task.is_dir():
             paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{task_name}")
-        archived_task = tasks_dir / DIR_ARCHIVE / task_name
-        if archived_task.is_dir():
-            paths.append(
-                f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}/{task_name}"
-            )
         return paths
 
-    # Legacy wide scope (no task_name): each direct child of tasks/ that is a
-    # directory and not the archive root, plus the whole archive subtree.
+    # Wide scope (no task_name): each direct task directory.
     for child in sorted(tasks_dir.iterdir()):
         if not child.is_dir():
             continue
-        if child.name == DIR_ARCHIVE:
-            continue
         paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{child.name}")
 
-    archive_dir = tasks_dir / DIR_ARCHIVE
-    if archive_dir.is_dir():
-        paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}")
-
-    return paths
-
-
-def safe_archive_paths_to_add(
-    repo_root: Path,
-    task_name: str | None = None,
-    modified_children: list[str] | None = None,
-) -> list[str]:
-    """Return paths to stage after `task.py archive`.
-
-    Scoped to ONLY the paths the archive operation actually touched:
-
-      - the archive subtree (where the freshly-moved task lives)
-      - the source task directory (for source-side deletes; caller pairs
-        this with `git rm --cached` since `git add` won't stage deletes
-        for a path that no longer exists in the working tree)
-      - any child task directories whose `task.json` was edited to drop
-        the archived parent (parent-children relationship update)
-
-    This narrow scope avoids "scope creep" — dirty changes in OTHER
-    active task dirs (parallel-window edits) are NOT bundled into the
-    archive commit. Callers handle each kind of change in its own
-    commit boundary.
-
-    Backwards-compat: with no arguments, the function walks the whole
-    `.trellis/tasks/` subtree the old way (active tasks + archive). New
-    callers should always pass `task_name`.
-    """
-    paths: list[str] = []
-    tasks_dir = repo_root / DIR_WORKFLOW / DIR_TASKS
-    if not tasks_dir.is_dir():
-        return paths
-
-    archive_dir = tasks_dir / DIR_ARCHIVE
-
-    if task_name is not None:
-        # Narrow scope — only paths that still exist on disk (so
-        # `git add` doesn't choke on the moved-away source). The caller
-        # handles the source-side deletes via `git rm --cached`
-        # explicitly.
-        if archive_dir.is_dir():
-            paths.append(
-                f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}"
-            )
-        for child_name in modified_children or []:
-            paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{child_name}")
-        return paths
-
-    # Legacy wide scope (no task_name): preserve old behavior so callers
-    # that have not been updated keep working.
-    if archive_dir.is_dir():
-        paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}")
-    for child in sorted(tasks_dir.iterdir()):
-        if not child.is_dir():
-            continue
-        if child.name == DIR_ARCHIVE:
-            continue
-        paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{child.name}")
     return paths
 
 
@@ -225,9 +152,7 @@ def safe_git_add(
 
     ``retry_on_index_lock`` opts into the bounded backoff-retry for a held
     ``.git/index.lock`` (see :func:`~.git.run_git_retry_index_lock`). It is
-    off by default: only the archive path, which has already moved the task
-    directory on disk by the time it stages, needs to wait out a transient
-    lock rather than fail.
+    off by default; callers that already changed files on disk can opt in.
     """
     if not paths:
         return True, False, ""
@@ -275,10 +200,6 @@ def print_gitignore_warning(paths: list[str]) -> None:
             "[WARN]   .trellis/tasks/<task-dir>/",
             file=sys.stderr,
         )
-        print(
-            "[WARN]   .trellis/tasks/archive/",
-            file=sys.stderr,
-        )
     print("[WARN]", file=sys.stderr)
     print(
         "[WARN] Recommended: change your .gitignore from `.trellis/` to specific",

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

@@ -22,7 +22,6 @@ import sys
 from pathlib import Path
 
 from .active_task import resolve_context_key
-from .continuation_record import status as continuity_status
 from .config import get_git_packages
 from .git import run_git
 from .packages_context import get_packages_section
@@ -559,8 +558,6 @@ def get_context_json(repo_root: Path | None = None) -> dict:
     if pkg_git_info:
         result["packageGit"] = pkg_git_info
 
-    result["continuity"] = continuity_status(repo_root)
-
     return result
 
 
@@ -647,8 +644,6 @@ def get_context_text(repo_root: Path | None = None) -> str:
             lines.append("[!] This task has prd.md - read it for task details")
     else:
         lines.append("(none)")
-    continuity = continuity_status(repo_root)
-    lines.append(f"Continuation Record: {continuity['status']}")
     lines.append("")
 
     # Active tasks
@@ -802,8 +797,6 @@ def get_context_record_json(repo_root: Path | None = None) -> dict:
     if pkg_git_info:
         result["packageGit"] = pkg_git_info
 
-    result["continuity"] = continuity_status(repo_root)
-
     return result
 
 
@@ -831,7 +824,7 @@ def get_context_text_record(repo_root: Path | None = None) -> str:
 
     # MY ACTIVE TASKS — first and prominent
     lines.append(f"## [!!!] MY ACTIVE TASKS (Assigned to {developer})")
-    lines.append("[!] Review whether any should be archived before recording this session.")
+    lines.append("Review task progress and remaining work before recording this session.")
     lines.append("")
 
     tasks_dir = get_tasks_dir(repo_root)

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

@@ -55,7 +55,7 @@ Translation examples (glob → matches / non-matches):
         matches only that exact file
     packages/cli/src/commands/*.ts
         matches packages/cli/src/commands/update.ts
-        not     packages/cli/src/commands/channel/spawn.ts
+        not     packages/cli/src/commands/teamwork/spawn.ts
     packages/cli/src/templates/**
         matches packages/cli/src/templates/trellis/index.ts (any depth)
         not     packages/cli/src/templates (the directory itself)

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

@@ -26,11 +26,10 @@ import json
 from pathlib import Path
 
 from .config import get_context_injection_limits
-from .context_projection import parse_context_manifest, project_agent_context
 from .git import branch_exists_locally
 from .io import read_json
 from .log import Colors, colored
-from .paths import FILE_TASK_JSON, get_repo_root
+from .paths import DIR_TASKS, DIR_WORKFLOW, 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
@@ -92,6 +91,12 @@ def cmd_add_context(args: argparse.Namespace) -> int:
     jsonl_file = target_dir / jsonl_name
     full_path = repo_root / path
 
+    from .task_continuity import task_mutation_guard
+
+    task_data = read_json(target_dir / FILE_TASK_JSON)
+    if not isinstance(task_data, dict):
+        print(colored(f"Error: task.json is unavailable at {target_dir}", Colors.RED))
+        return 1
     entry_type = "file"
     if full_path.is_dir():
         entry_type = "directory"
@@ -115,8 +120,12 @@ def cmd_add_context(args: argparse.Namespace) -> int:
     else:
         entry = {"file": path, "reason": reason}
 
-    with jsonl_file.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    with task_mutation_guard(repo_root, target_dir, task_data) as allowed:
+        if not allowed:
+            print(colored("TASK_TRANSFER_ACTIVE: task changes are fenced until ownership is consumed or released", Colors.RED))
+            return 1
+        with jsonl_file.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
 
     print(colored(f"Added {entry_type}: {path}", Colors.GREEN))
     return 0
@@ -126,19 +135,6 @@ def cmd_add_context(args: argparse.Namespace) -> int:
 # Command: validate
 # =============================================================================
 
-def curated_entry_count(jsonl_file: Path) -> int | None:
-    """Count curated entries in a jsonl context manifest.
-
-    Returns None when the file does not exist — `task.py create` seeds the
-    manifests only on sub-agent-capable platforms, so an absent file means no
-    sub-agent will ever read it and callers should not gate on it. A curated
-    entry is a JSON object row carrying a truthy ``file`` (or legacy ``path``)
-    value: the same rows the sub-agent injection hook materializes.
-    """
-    entries, _, manifest_exists = parse_context_manifest(jsonl_file)
-    return len(entries) if manifest_exists else None
-
-
 def cmd_validate(args: argparse.Namespace) -> int:
     """Validate JSONL context files."""
     repo_root = get_repo_root()
@@ -199,6 +195,55 @@ def _is_exempt_from_code_file_warning(file_path: str, task_rel: str) -> bool:
     return False
 
 
+def _resolve_context_entry_path(
+    file_path: str, repo_root: Path, task_dir: Path | None
+) -> Path | None:
+    """Bind historical self-references to their archive copy without fallback."""
+    repo_path = repo_root / file_path
+    if task_dir is None:
+        return repo_path
+
+    try:
+        task_parts = task_dir.resolve().relative_to(repo_root.resolve()).parts
+    except ValueError:
+        return repo_path
+
+    archive_prefix = (DIR_WORKFLOW, DIR_TASKS, "archive")
+    if len(task_parts) != 5 or task_parts[:3] != archive_prefix:
+        return repo_path
+
+    year_month = task_parts[3]
+    if (
+        len(year_month) != 7
+        or year_month[4] != "-"
+        or not year_month[:4].isdigit()
+        or not year_month[5:].isdigit()
+    ):
+        return repo_path
+
+    historical_root = f"{DIR_WORKFLOW}/{DIR_TASKS}/{task_dir.name}"
+    posix_path = file_path.replace("\\", "/")
+    if posix_path == historical_root:
+        relative_parts: tuple[str, ...] = ()
+    elif posix_path.startswith(f"{historical_root}/"):
+        relative_path = posix_path[len(historical_root) + 1 :]
+        if relative_path.endswith("/"):
+            relative_path = relative_path[:-1]
+        relative_parts = tuple(relative_path.split("/")) if relative_path else ()
+        if any(part in ("", ".", "..") for part in relative_parts):
+            return None
+    else:
+        return repo_path
+
+    try:
+        archive_root = task_dir.resolve()
+        resolved_path = task_dir.joinpath(*relative_parts).resolve()
+        resolved_path.relative_to(archive_root)
+    except (OSError, RuntimeError, ValueError):
+        return None
+    return resolved_path
+
+
 def _validate_jsonl(jsonl_file: Path, repo_root: Path, task_dir: Path | None = None) -> int:
     """Validate a single JSONL file.
 
@@ -207,10 +252,11 @@ def _validate_jsonl(jsonl_file: Path, repo_root: Path, task_dir: Path | None = N
     accepting them here would pass locally and fail later. Other rows without
     a ``file`` field are skipped silently, matching what consumers do.
 
-    The same Python projection that the shared Hook renders is evaluated for
-    each role. Hygiene warnings remain advisory; every source that would be
-    truncated, omitted, or indexed instead of appearing as complete body text
-    is a hard validation error.
+    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
@@ -226,57 +272,104 @@ def _validate_jsonl(jsonl_file: Path, repo_root: Path, task_dir: Path | None = N
         except ValueError:
             task_rel = ""
 
-    entries, manifest_problems, _ = parse_context_manifest(jsonl_file)
-    for problem in manifest_problems:
-        print(f"  {colored(f'{file_name}:{problem.line}: {problem.message}', Colors.RED)}")
-        errors += 1
+    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():
+        line_num += 1
+        if not line.strip():
+            continue
+
+        try:
+            data = json.loads(line)
+        except json.JSONDecodeError:
+            print(f"  {colored(f'{file_name}:{line_num}: Invalid JSON', Colors.RED)}")
+            errors += 1
+            continue
+
+        if not isinstance(data, dict):
+            print(
+                f"  {colored(f'{file_name}:{line_num}: Expected a JSON object', Colors.RED)}"
+            )
+            errors += 1
+            continue
+
+        if "_example" in data:
+            error_message = (
+                f"{file_name}:{line_num}: Placeholder `_example` row left by an older "
+                "task.py create — delete this line, or replace it with "
+                '{"file": "<path>", "reason": "<why>"}'
+            )
+            print(f"  {colored(error_message, Colors.RED)}")
+            errors += 1
+            continue
+
+        file_path = data.get("file")
+        entry_type = data.get("type", "file")
 
-    for entry in entries:
-        if entry.entry_type == "directory":
+        if not file_path:
+            # Comment / unknown row without a path — skip silently
             continue
-        extension = Path(entry.path).suffix.lower()
+
+        if not isinstance(file_path, str):
+            # A truthy non-string (e.g. {"file": 1}) reached path joining and
+            # raised TypeError, so validation crashed on the row it exists to
+            # report.
+            print(
+                f"  {colored(f'{file_name}:{line_num}: `file` must be a string path', Colors.RED)}"
+            )
+            errors += 1
+            continue
+
+        real_entries += 1
+        full_path = _resolve_context_entry_path(file_path, repo_root, task_dir)
+        if entry_type == "directory":
+            if full_path is None or not full_path.is_dir():
+                print(f"  {colored(f'{file_name}:{line_num}: Directory not found: {file_path}', Colors.RED)}")
+                errors += 1
+            continue
+
+        if full_path is None or 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(
-            entry.path, task_rel
+            file_path, task_rel
         ):
             warning_message = (
-                f"{file_name}:{entry.line}: Warning: {entry.path} looks like a code file — "
+                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"
             )
             print(f"  {colored(warning_message, Colors.YELLOW)}")
 
-    if errors == 0 and not entries:
-        # Seed-only / empty manifest: sub-agents dispatched for this task
-        # would run with zero spec context (#573). Silent-green here is how
-        # more than half the tasks in the report ended up uncurated.
-        action = file_name.split(".", 1)[0]
-        print(
-            f"  {colored(f'{file_name}: ✗ (0 curated entries — sub-agents would get zero spec context)', Colors.RED)}"
-        )
-        print(
-            f"    Curate it:  python3 .trellis/scripts/task.py add-context <task> {action} <path> \"<why>\""
-        )
-        print(
-            "    Intentionally empty? Bypass at start: task.py start <task> --allow-empty-context"
-        )
-        return 1
+        if max_file_bytes:
+            # Advisory hygiene warning, so it must never be what fails
+            # `validate`. `stat()` can still raise after the `is_file()` check
+            # above — a permission change, or the file removed in between.
+            try:
+                size: int | None = full_path.stat().st_size
+            except OSError:
+                size = None
+            if size is not None and size > max_file_bytes:
+                warning_message = (
+                    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"
+                )
+                print(f"  {colored(warning_message, Colors.YELLOW)}")
 
-    if errors == 0 and task_dir is not None:
-        role = jsonl_file.stem
-        projection = project_agent_context(
-            repo_root, task_dir, role, get_context_injection_limits(repo_root)
+    if errors == 0 and real_entries == 0:
+        print(
+            f"  {colored(f'{file_name}: ✓ (no context entries; manifests are optional)', Colors.YELLOW)}"
         )
-        for issue in projection.issues:
-            line_label = str(issue.line) if issue.line is not None else "artifact"
-            message = (
-                f"{file_name}:{line_label}: role={issue.role} source={issue.category} "
-                f"path={issue.path}: cannot be injected in full — {issue.reason}"
-            )
-            print(f"  {colored(message, Colors.RED)}")
-            errors += 1
+        return 0
 
     if errors == 0:
-        print(f"  {colored(f'{file_name}: ✓ ({len(entries)} entries)', Colors.GREEN)}")
+        print(f"  {colored(f'{file_name}: ✓ ({real_entries} entries)', Colors.GREEN)}")
     else:
         print(f"  {colored(f'{file_name}: ✗ ({errors} errors)', Colors.RED)}")
 
@@ -320,7 +413,7 @@ def cmd_list_context(args: argparse.Namespace) -> int:
             if not isinstance(data, dict):
                 continue
 
-            file_path = data.get("file") or data.get("path")
+            file_path = data.get("file")
             if not file_path:
                 # Placeholder / comment row — don't count as a real entry
                 continue