feat(plugins/git): operator Co-authored-by trailer (#158)

Add a small `git` plugin as a configuration point for non-observability
git concerns — currently just operator attribution; intended to grow
into a home for other git-related hooks, config, and tooling.

Why a separate plugin: the observability plugin owns git event-emission
hooks (post-commit, pre-push, …) and that's its job. This plugin holds
non-observability git concerns so the two stay focused and can evolve
independently.

Changes:
- Add plugins/git/.claude-plugin/plugin.json declaring SYN_OPERATOR_NAME
  and SYN_OPERATOR_EMAIL via requires_env so the agentic-isolation
  orchestrator auto-forwards them when set in the host env.
- Add plugins/git/hooks/prepare-commit-msg — appends
  'Co-authored-by: NAME <EMAIL>' when both operator env vars are set.
  Skips merge/squash/template/commit message sources. Idempotent.
  Strips CR/LF from operator inputs to prevent newline-injection of
  extra trailers. No-op when env vars unset (backward compatible).
- Add plugins/git/README.md framing the plugin's scope.
- Update providers/workspaces/claude-cli/manifest.yaml to bake the
  new plugin into the image.
- Update entrypoint.sh: compose git hooks from BOTH observability
  (event emission) and the new git plugin (attribution) into a single
  runtime directory at $HOME/.git-hooks, then point core.hooksPath
  there. Multiple plugins can now contribute git hooks. Observability
  is otherwise untouched.

Resolves #158.

Verification (rebuilt 2.1.126 image):
- 27/27 just test-workspace passes.
- Hook composition: 6 symlinks under $HOME/.git-hooks/ — 5 to
  observability/hooks/git/, 1 to git/hooks/prepare-commit-msg.
- prepare-commit-msg matrix in container:
  - merge|squash|template|commit source -> no trailer
  - message source, no env       -> no trailer
  - message source, with env     -> trailer appended
  - trailer already present      -> idempotent
  - newline-injected env var     -> sanitized, only 1 trailer line
- Observability git_commit events still emit on stderr as before.

Author: NeuralEmpowerment

plugins/git/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "git",
+  "version": "0.1.0",
+  "description": "Git configuration point for the workspace — non-observability git concerns. Currently owns operator Co-authored-by attribution; intended to grow into a home for other git-related hooks, config, and tooling.",
+  "author": {"name": "NeuralEmpowerment"},
+  "repository": "https://github.com/AgentParadise/agentic-primitives",
+  "requires_env": {
+    "SYN_OPERATOR_NAME": {
+      "description": "Operator display name. When set together with SYN_OPERATOR_EMAIL, every workspace commit gets a 'Co-authored-by' trailer attributing the operator who sponsored the workspace.",
+      "required": false,
+      "secret": false
+    },
+    "SYN_OPERATOR_EMAIL": {
+      "description": "Operator email — must match a verified GitHub account so the co-author renders with the operator's avatar on PRs.",
+      "required": false,
+      "secret": false
+    }
+  }
+}

plugins/git/README.md

@@ -0,0 +1,22 @@
+# git
+
+Git configuration point for the workspace — a home for **non-observability** git concerns: hooks, config, and tooling that affect how the agent interacts with git, but aren't about emitting events.
+
+> **Why a separate plugin?** The `observability` plugin owns git hooks that emit events (`post-commit`, `pre-push`, etc.) — that's its job. This plugin holds everything else git-related so observability stays focused. Both plugins can ship git hooks; the workspace entrypoint composes them into a single `core.hooksPath` at startup.
+
+## What's here today
+
+- **`hooks/prepare-commit-msg`** — operator `Co-authored-by:` attribution. When `SYN_OPERATOR_NAME` and `SYN_OPERATOR_EMAIL` are both set, the hook appends a co-author trailer to every commit message so PRs the workspace opens are attributed to the operator who sponsored it.
+
+## Operator attribution
+
+Two env vars enable the trailer:
+
+- `SYN_OPERATOR_NAME` — display name (e.g. `"NeuralEmpowerment"`)
+- `SYN_OPERATOR_EMAIL` — must match a verified GitHub account so the co-author renders with the operator's avatar
+
+Both are declared in `requires_env` of `.claude-plugin/plugin.json`, so an `agentic-isolation` orchestrator that has them in the host env will auto-forward them into the container.
+
+When unset, the hook is a no-op — backward-compatible.
+
+The hook skips auto-generated message sources (`merge`, `squash`, `template`, `commit`) to avoid polluting them, and is idempotent (won't double-append the same trailer).

plugins/git/hooks/prepare-commit-msg

@@ -0,0 +1,51 @@
+#!/bin/sh
+# prepare-commit-msg — append operator Co-authored-by trailer.
+# Plugin marker for install.py uninstall detection: agentic_events
+#
+# When the workspace is run by an operator (e.g. via Syntropic137 selfhost),
+# SYN_OPERATOR_NAME and SYN_OPERATOR_EMAIL identify the human who sponsored
+# the workspace. This hook adds them as a co-author on every agent commit so
+# the operator gets attribution on PRs the workspace opens.
+#
+# Behavior:
+#   - No-op when either env var is unset (backward compatible).
+#   - Skipped on auto-generated message sources (merge/squash/template/commit)
+#     so we don't pollute them.
+#   - Idempotent — won't append if the same trailer already exists.
+#   - Always exits 0 — never blocks a commit on attribution failure.
+
+COMMIT_MSG_FILE="$1"
+COMMIT_SOURCE="$2"
+
+# Skip auto-generated message sources so we don't pollute them.
+#   merge    — message produced by `git merge`
+#   squash   — message produced by `git merge --squash`
+#   template — user has a commit.template configured
+#   commit   — reusing an existing commit (e.g. `git commit --amend`,
+#              `git cherry-pick`). The original message already has any
+#              trailer it should have; idempotency below handles re-adds.
+case "$COMMIT_SOURCE" in
+    merge|squash|template|commit) exit 0 ;;
+esac
+
+if [ -z "$SYN_OPERATOR_NAME" ] || [ -z "$SYN_OPERATOR_EMAIL" ]; then
+    exit 0
+fi
+
+# Strip CR/LF from operator inputs — env vars are normally well-formed but we
+# don't want a stray newline in either to inject additional trailers.
+NAME=$(printf '%s' "$SYN_OPERATOR_NAME" | tr -d '\r\n')
+EMAIL=$(printf '%s' "$SYN_OPERATOR_EMAIL" | tr -d '\r\n')
+
+if [ -z "$NAME" ] || [ -z "$EMAIL" ]; then
+    exit 0
+fi
+
+TRAILER="Co-authored-by: ${NAME} <${EMAIL}>"
+
+if grep -qF "$TRAILER" "$COMMIT_MSG_FILE" 2>/dev/null; then
+    exit 0
+fi
+
+printf '\n%s\n' "$TRAILER" >> "$COMMIT_MSG_FILE"
+exit 0

providers/workspaces/claude-cli/manifest.yaml

@@ -36,6 +36,7 @@ plugins:
     - sdlc
     - workspace
     - observability
+    - git
   # Install location in the image
   install_path: /opt/agentic/plugins
 

providers/workspaces/claude-cli/scripts/entrypoint.sh

@@ -100,23 +100,43 @@ if [ -n "${GIT_AUTHOR_NAME}" ]; then
     git config --global init.defaultBranch main
 fi
 
-# Install observability git hooks globally (ADR-043).
+# Install workspace git hooks globally (ADR-043).
 #
 # core.hooksPath is a git global config that overrides the per-repo .git/hooks/
-# directory. Setting it here (at container startup) means post-commit, pre-push,
-# post-merge, and post-rewrite hooks fire for EVERY repo cloned or initialized
-# inside this container — including repos cloned by the agent mid-task.
+# directory. Setting it here (at container startup) means our hooks fire for
+# EVERY repo cloned or initialized inside this container — including repos
+# cloned by the agent mid-task.
 #
-# The hooks emit JSONL observability events to stderr. The docker exec stream in
-# AgenticEventStreamAdapter uses stderr=STDOUT to capture them alongside Claude's
-# stdout, and WorkflowExecutionEngine stores them in TimescaleDB.
+# Multiple plugins can contribute git hooks. We compose them into a single
+# runtime directory ($GIT_HOOKS_DIR) and point core.hooksPath at it:
+#   - observability/hooks/git/  → event-emission (post-commit, pre-push, …)
+#   - git/hooks/                → other git concerns (prepare-commit-msg, …)
 #
-# Without this line, git hooks only fire in repos that have their own .git/hooks/
-# scripts, which is almost never the case for freshly cloned repos.
-GIT_HOOKS_DIR="${AGENTIC_PLUGINS_DIR:-/opt/agentic/plugins}/observability/hooks/git"
-if [ -d "${GIT_HOOKS_DIR}" ]; then
+# Each plugin owns hook filenames it ships; collisions across plugins are not
+# expected today. If two plugins ever ship the same hook name, the second
+# symlink wins.
+#
+# Observability hooks emit JSONL events to stderr; the docker exec stream in
+# AgenticEventStreamAdapter uses stderr=STDOUT to capture them alongside
+# Claude's stdout, and WorkflowExecutionEngine stores them in TimescaleDB.
+GIT_HOOKS_DIR="${HOME}/.git-hooks"
+mkdir -p "${GIT_HOOKS_DIR}"
+
+PLUGINS_BASE="${AGENTIC_PLUGINS_DIR:-/opt/agentic/plugins}"
+for src_dir in "${PLUGINS_BASE}/observability/hooks/git" "${PLUGINS_BASE}/git/hooks"; do
+    [ -d "${src_dir}" ] || continue
+    for src in "${src_dir}"/*; do
+        [ -f "${src}" ] || continue
+        name=$(basename "${src}")
+        # Skip non-hook files (installer, docs)
+        case "${name}" in install.py|*.md|*.txt) continue ;; esac
+        ln -sf "${src}" "${GIT_HOOKS_DIR}/${name}"
+    done
+done
+
+if [ -n "$(ls -A "${GIT_HOOKS_DIR}" 2>/dev/null)" ]; then
     git config --global core.hooksPath "${GIT_HOOKS_DIR}"
-    echo "[entrypoint] Git observability hooks installed from ${GIT_HOOKS_DIR}"
+    echo "[entrypoint] Workspace git hooks composed at ${GIT_HOOKS_DIR}"
 fi
 
 # Also set committer identity (git uses both for commits)