@mindfoldhq/trellis 0.6.0-beta.5 → 0.6.0-beta.6

package/dist/migrations/manifests/0.5.11.json

@@ -0,0 +1,16 @@
+{
+  "version": "0.5.11",
+  "description": "Patch: drop 0.5.10 `git add -f` retry + new `session_auto_commit` config + session-start update hint.",
+  "breaking": false,
+  "recommendMigrate": false,
+  "changelog": "**Bug Fixes:**\n- fix(scripts): drop `git add -f` auto-retry from 0.5.10. When `.gitignore` excludes `.trellis/`, `add_session.py` and `task.py archive` print a warning and skip auto-commit instead of force-staging.\n\n**Enhancements:**\n- feat(scripts): new `session_auto_commit: true | false` in `.trellis/config.yaml` (default `true`). Set `false` to skip auto stage + commit — journal / archive files still write to disk. Closes #245.\n- feat(scripts): `get_context.py` shows `Trellis update available: <current> -> <latest>` once per session when local install lags. 1-second timeout, failures silent. Closes #254.",
+  "migrations": [],
+  "configSectionsAdded": [
+    {
+      "file": ".trellis/config.yaml",
+      "sentinel": "session_auto_commit:",
+      "sectionHeading": "Session Auto-Commit"
+    }
+  ],
+  "notes": "Patch on top of 0.5.10. Run `trellis update` — your `.trellis/config.yaml` gets a commented-out `session_auto_commit: true` block appended automatically. Uncomment and flip to `false` if your `.gitignore` excludes `.trellis/` and you want auto-commit off entirely."
+}

package/dist/migrations/manifests/0.6.0-beta.6.json

@@ -0,0 +1,16 @@
+{
+  "version": "0.6.0-beta.6",
+  "description": "Beta patch: brings v0.5.11 fixes into 0.6 beta line — drops `git add -f` auto-retry + new `session_auto_commit` config.",
+  "breaking": false,
+  "recommendMigrate": false,
+  "changelog": "**Bug Fixes:**\n- fix(scripts): drop `git add -f` auto-retry from 0.6.0-beta.5. When `.gitignore` excludes `.trellis/`, `add_session.py` and `task.py archive` print a warning and skip auto-commit instead of force-staging.\n\n**Enhancements:**\n- feat(scripts): new `session_auto_commit: true | false` in `.trellis/config.yaml` (default `true`). Set `false` to skip auto stage + commit — journal / archive files still write to disk. Closes #245.",
+  "migrations": [],
+  "configSectionsAdded": [
+    {
+      "file": ".trellis/config.yaml",
+      "sentinel": "session_auto_commit:",
+      "sectionHeading": "Session Auto-Commit"
+    }
+  ],
+  "notes": "Beta patch on top of 0.6.0-beta.5. Run `trellis update` — your `.trellis/config.yaml` gets a commented-out `session_auto_commit: true` block appended automatically. Uncomment and flip to `false` if your `.gitignore` excludes `.trellis/` and you want auto-commit off entirely."
+}

package/dist/templates/trellis/config.yaml

@@ -14,6 +14,24 @@ session_commit_message: "chore: record journal"
 # Maximum lines per journal file before rotating to a new one
 max_journal_lines: 2000
 
+#-------------------------------------------------------------------------------
+# Session Auto-Commit
+#-------------------------------------------------------------------------------
+
+# Auto-commit behavior for session journal + task archive operations.
+# - true (default): scripts auto-stage and auto-commit journal / task changes
+#   after add_session.py / task.py archive runs.
+# - false: scripts do not touch git. Files (journal-*.md, task archive moves)
+#   are still written to disk; you decide whether to git add / commit.
+#
+# Use `false` if your project's .gitignore intentionally excludes `.trellis/`
+# and you want session data kept local-only, or if you prefer to review
+# staged changes manually before each commit.
+#
+# Accepts: true / false / yes / no / 1 / 0 / on / off (case-insensitive).
+#
+# session_auto_commit: true
+
 #-------------------------------------------------------------------------------
 # Task Lifecycle Hooks
 #-------------------------------------------------------------------------------

package/dist/templates/trellis/scripts/add_session.py

@@ -44,6 +44,7 @@ from common.safe_commit import (
 from common.tasks import load_task
 from common.config import (
     get_packages,
+    get_session_auto_commit,
     get_session_commit_message,
     get_max_journal_lines,
     is_monorepo,
@@ -322,16 +323,27 @@ def _auto_commit_workspace(repo_root: Path) -> None:
 
     Path scope is restricted to specific products (journal files, index.md,
     active task dirs, the archive subtree). We never `git add` the whole
-    `.trellis/` tree, and if `.gitignore` blocks the specific paths we retry
-    with `git add -f <those-specific-paths>` — never `-f .trellis/`.
+    `.trellis/` tree, and if `.gitignore` blocks the specific paths we
+    warn + skip — never retry with ``-f``.
+
+    Honors ``session_auto_commit`` in ``.trellis/config.yaml``: when set to
+    ``false``, this function returns immediately without touching git
+    (journal/index files are still written to disk by the caller).
     """
+    if not get_session_auto_commit(repo_root):
+        print(
+            "[OK] session_auto_commit: false — skipping git stage/commit.",
+            file=sys.stderr,
+        )
+        return
+
     commit_msg = get_session_commit_message(repo_root)
     paths = safe_trellis_paths_to_add(repo_root)
     if not paths:
         print("[OK] No workspace changes to commit.", file=sys.stderr)
         return
 
-    success, used_force, err = safe_git_add(paths, repo_root)
+    success, _, err = safe_git_add(paths, repo_root)
     if not success:
         if err and "ignored by" in err.lower():
             print_gitignore_warning(paths)
@@ -342,12 +354,6 @@ def _auto_commit_workspace(repo_root: Path) -> None:
             )
         return
 
-    if used_force:
-        print(
-            "[OK] Staged Trellis-owned paths with -f (specific paths, not .trellis/).",
-            file=sys.stderr,
-        )
-
     # Check if there are staged changes for the paths we just staged.
     rc, _, _ = run_git(
         ["diff", "--cached", "--quiet", "--", *paths], cwd=repo_root

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

@@ -36,6 +36,29 @@ def _unquote(s: str) -> str:
     return s
 
 
+def _strip_inline_comment(value: str) -> str:
+    """Strip ` # …` inline comments while preserving `#` inside quoted strings.
+
+    YAML treats ` #` (space-hash) as a comment opener; bare `#` inside a token
+    is part of the value. Quoted strings are immune.
+
+    Mirrors :func:`common.trellis_config._strip_inline_comment` so both
+    parsers handle ``key: value  # comment`` identically.
+    """
+    in_quote: str | None = None
+    for idx, ch in enumerate(value):
+        if in_quote:
+            if ch == in_quote:
+                in_quote = None
+            continue
+        if ch in ('"', "'"):
+            in_quote = ch
+            continue
+        if ch == "#" and (idx == 0 or value[idx - 1].isspace()):
+            return value[:idx]
+    return value
+
+
 def parse_simple_yaml(content: str) -> dict:
     """Parse simple YAML with nested dict support (no dependencies).
 
@@ -93,7 +116,8 @@ def _parse_yaml_block(
         elif ":" in stripped:
             key, _, value = stripped.partition(":")
             key = key.strip()
-            value = _unquote(value.strip())
+            value = _strip_inline_comment(value).strip()
+            value = _unquote(value)
             current_list = None
 
             if value:
@@ -142,6 +166,7 @@ def _next_content_line(lines: list[str], start: int) -> tuple[int, str]:
 # Defaults
 DEFAULT_SESSION_COMMIT_MESSAGE = "chore: record journal"
 DEFAULT_MAX_JOURNAL_LINES = 2000
+DEFAULT_SESSION_AUTO_COMMIT = True
 
 CONFIG_FILE = "config.yaml"
 
@@ -187,6 +212,37 @@ def get_max_journal_lines(repo_root: Path | None = None) -> int:
         return DEFAULT_MAX_JOURNAL_LINES
 
 
+def get_session_auto_commit(repo_root: Path | None = None) -> bool:
+    """Whether scripts should auto-stage + auto-commit session/task changes.
+
+    Governs both ``add_session.py:_auto_commit_workspace`` and
+    ``task_store.py:_auto_commit_archive``.
+
+    Default: ``True`` (existing behavior — auto-stage + auto-commit).
+    Set ``session_auto_commit: false`` in ``.trellis/config.yaml`` to skip
+    auto-staging entirely; the journal/archive files are still written to
+    disk, but the user manages ``git add`` / ``git commit`` themselves.
+
+    Accepts native YAML booleans (``true`` / ``false``) and the string
+    aliases ``true / false / yes / no / 1 / 0 / on / off`` (case-insensitive).
+    Invalid values fall back to ``True`` with a stderr warning.
+    """
+    config = _load_config(repo_root)
+    raw = config.get("session_auto_commit", DEFAULT_SESSION_AUTO_COMMIT)
+    if isinstance(raw, bool):
+        return raw
+    s = str(raw).strip().lower()
+    if s in ("true", "yes", "1", "on"):
+        return True
+    if s in ("false", "no", "0", "off"):
+        return False
+    print(
+        f"[WARN] invalid session_auto_commit value: {raw!r}; using true (default)",
+        file=sys.stderr,
+    )
+    return DEFAULT_SESSION_AUTO_COMMIT
+
+
 def get_hooks(event: str, repo_root: Path | None = None) -> list[str]:
     """Get hook commands for a lifecycle event.
 

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

@@ -15,14 +15,19 @@ Design
 ------
 - Scripts only stage SPECIFIC product paths (journal files, index.md, the
   current task dir, the archive dir). Never the whole `.trellis/` tree.
-- If plain `git add <specific>` fails with "ignored by", retry with
-  `git add -f <specific>` — forcing only the paths the script knows it owns.
-  This is safe because the paths are narrow; it is NOT equivalent to
-  `git add -f .trellis/` (which would fan out to backups/worktrees/runtime).
-- If the -f retry also fails, print an explicit warning that includes a
-  negative example: ``Do NOT use `git add -f .trellis/` ...``
-
-The wider-grain forbidden command stays forbidden.
+- 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
+  auto-commit; users who want auto-staging can either fix their `.gitignore`
+  or set ``session_auto_commit: false`` and manage git themselves.
+- The warning includes a negative example: ``Do NOT use `git add -f .trellis/` ...``
+  so any AI rereading the log doesn't reinvent the bug.
+
+History note: 0.5.10 introduced an automatic ``git add -f`` retry on the
+specific paths. That was reverted in 0.5.11 — auto-forcing into a tree the
+user had gitignored violates user intent even when the path list is narrow.
+The wider-grain forbidden command stays forbidden, and the narrow-grain auto
+``-f`` is gone too.
 """
 
 from __future__ import annotations
@@ -145,20 +150,18 @@ def _stderr_indicates_ignored(stderr: str) -> bool:
 def safe_git_add(
     paths: list[str], repo_root: Path
 ) -> tuple[bool, bool, str]:
-    """Run `git add` on specific paths, retrying with -f if .gitignore blocks.
+    """Run `git add` on specific paths; never retry with -f.
 
-    Returns (success, used_force, stderr). On success, callers should still
-    `git diff --cached` to detect whether anything was actually staged.
+    Returns ``(success, used_force, stderr)``. The ``used_force`` field is
+    kept for signature compatibility with the 0.5.10 implementation but is
+    always ``False`` — we never auto-force.
 
     Behavior:
       - No paths passed → success, no force, empty stderr.
-      - Plain `git add <paths>` succeeds → return.
-      - Plain fails with "ignored by" → retry with `git add -f <paths>`.
-      - Retry succeeds → return success with used_force=True.
-      - Retry fails → return failure; caller should print the gitignore
-        warning (see :func:`print_gitignore_warning`).
-      - Plain fails with a non-ignored error → return failure; do NOT retry
-        with -f (we only force when ignore is the cause).
+      - Plain ``git add -- <paths>`` succeeds → return success.
+      - Plain fails (any reason — ignored or otherwise) → return failure with
+        the stderr. Callers should inspect the stderr (see
+        :func:`print_gitignore_warning`) and skip the auto-commit.
     """
     if not paths:
         return True, False, ""
@@ -166,14 +169,7 @@ def safe_git_add(
     rc, _, err = run_git(["add", "--", *paths], cwd=repo_root)
     if rc == 0:
         return True, False, ""
-
-    if not _stderr_indicates_ignored(err):
-        return False, False, err
-
-    rc2, _, err2 = run_git(["add", "-f", "--", *paths], cwd=repo_root)
-    if rc2 == 0:
-        return True, True, err2 or err
-    return False, True, err2 or err
+    return False, False, err
 
 
 def print_gitignore_warning(paths: list[str]) -> None:
@@ -187,6 +183,15 @@ def print_gitignore_warning(paths: list[str]) -> None:
         "[WARN] git add failed because .trellis/ paths are ignored by your .gitignore.",
         file=sys.stderr,
     )
+    print(
+        "[WARN] Skipping auto-commit. The journal/task files were still written to disk;",
+        file=sys.stderr,
+    )
+    print(
+        "[WARN] git was not touched.",
+        file=sys.stderr,
+    )
+    print("[WARN]", file=sys.stderr)
     print(
         "[WARN] Trellis manages these specific paths and they should be tracked:",
         file=sys.stderr,
@@ -219,6 +224,27 @@ def print_gitignore_warning(paths: list[str]) -> None:
     for sub in TRELLIS_IGNORED_SUBPATHS:
         print(f"[WARN]   {sub}", file=sys.stderr)
     print("[WARN]", file=sys.stderr)
+    print(
+        "[WARN] Or, if you intentionally keep .trellis/ local-only, set in",
+        file=sys.stderr,
+    )
+    print(
+        "[WARN] .trellis/config.yaml:",
+        file=sys.stderr,
+    )
+    print(
+        "[WARN]   session_auto_commit: false",
+        file=sys.stderr,
+    )
+    print(
+        "[WARN] so the scripts skip git entirely and you can review / commit",
+        file=sys.stderr,
+    )
+    print(
+        "[WARN] manually with `git status` / `git add` / `git commit`.",
+        file=sys.stderr,
+    )
+    print("[WARN]", file=sys.stderr)
     print(
         "[WARN] Do NOT use `git add -f .trellis/` — it pulls in backups, worktrees,",
         file=sys.stderr,

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

@@ -24,6 +24,7 @@ from pathlib import Path
 
 from .config import (
     get_packages,
+    get_session_auto_commit,
     is_monorepo,
     resolve_package,
     validate_package,
@@ -391,16 +392,28 @@ def _auto_commit_archive(task_name: str, repo_root: Path) -> None:
     """Stage Trellis-owned task paths and commit after archive.
 
     Only stages specific subpaths (the archive subtree and active task dirs),
-    never the whole `.trellis/` tree. If `.gitignore` excludes `.trellis/`,
-    falls back to `git add -f <specific>` and emits a warning that explicitly
-    forbids `git add -f .trellis/` (which would fan out to caches/backups).
+    never the whole ``.trellis/`` tree. If ``.gitignore`` blocks the paths,
+    we warn + skip — we do NOT retry with ``git add -f``. The warning
+    explicitly forbids ``git add -f .trellis/`` (which would fan out to
+    caches/backups) and points users at ``session_auto_commit: false``.
+
+    Honors ``session_auto_commit`` in ``.trellis/config.yaml``: when set to
+    ``false``, this function returns immediately without touching git
+    (the archive directory move on disk is unaffected).
     """
+    if not get_session_auto_commit(repo_root):
+        print(
+            "[OK] session_auto_commit: false — skipping git stage/commit.",
+            file=sys.stderr,
+        )
+        return
+
     paths = safe_archive_paths_to_add(repo_root)
     if not paths:
         print("[OK] No task changes to commit.", file=sys.stderr)
         return
 
-    success, used_force, err = safe_git_add(paths, repo_root)
+    success, _, err = safe_git_add(paths, repo_root)
     if not success:
         if err and "ignored by" in err.lower():
             print_gitignore_warning(paths)
@@ -411,12 +424,6 @@ def _auto_commit_archive(task_name: str, repo_root: Path) -> None:
             )
         return
 
-    if used_force:
-        print(
-            "[OK] Staged Trellis-owned paths with -f (specific paths, not .trellis/).",
-            file=sys.stderr,
-        )
-
     rc, _, _ = run_git(
         ["diff", "--cached", "--quiet", "--", *paths], cwd=repo_root
     )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindfoldhq/trellis",
-  "version": "0.6.0-beta.5",
+  "version": "0.6.0-beta.6",
   "description": "AI capabilities grow like ivy — Trellis provides the structure to guide them along a disciplined path",
   "type": "module",
   "main": "./dist/index.js",