@jenga-ai/agent 1.2.4 → 2.0.0

package/skills/close-story/scripts/check-privatized.sh

@@ -0,0 +1,345 @@
+#!/usr/bin/env bash
+# ---------------------------------------------------------------------------
+# skills/close-story/scripts/check-privatized.sh
+#
+# Static (run-independent) `.publicignore` membership check for a single
+# board ticket, invoked by /close-story at both task granularity (Step 2's
+# per-task loop) and story granularity (Step 4's finalization), per
+# E51_S03_T03. Unlike `Merged` (skills/self-sync/scripts/mark-merged.sh) and
+# `Publicized` (skills/mirror-public/scripts/mark-publicized.sh, E51_S03_T02),
+# which both react to a specific run's file diff, `Privatized` has NO
+# dependency on any run ever having occurred -- it is a pure blocklist
+# membership test against the ticket's own derived touched-file list, per
+# templates/SCRUM_BOARD_SCHEMA.md's "Static vs. Reactive Status Setting"
+# section.
+#
+# Usage: check-privatized.sh <id> <board-file-path>
+#
+#   <id>               EST ticket id -- a task id (E##_S##_T##) or a story id
+#                       (E##_S##). The anchored-grep commit matching (below)
+#                       is what keeps a story id from over-matching its own
+#                       children's commits, so the same script handles both
+#                       granularities with no separate code path.
+#   <board-file-path>   Path to the ticket's own board markdown file (task or
+#                       story), used to read its current `status:` and as the
+#                       write target.
+#
+# Touched-file derivation -- IDENTICAL technique to
+# skills/self-sync/scripts/mark-merged.sh (reused, not reinvented, per this
+# task's own description):
+#   1. git log --all --no-merges --extended-regexp \
+#        --grep="<id>([^0-9_]|$)" --pretty=format:'%H'
+#      The anchored pattern (not a plain substring grep) is required so a
+#      story id like "E51_S03" does not over-match every one of its own
+#      child tasks' commits -- the character immediately following a story
+#      id in a child task's commit message is "_", which the anchor
+#      excludes.
+#   2. Per matched commit: `git diff --name-only <sha>~1..<sha>`, falling
+#      back to `git diff-tree --no-commit-id --name-only -r <sha>` for a
+#      root commit with no parent.
+#   3. Union (dedup) the file paths across all matched commits.
+#   4. Zero matched commits -> nothing to check -> UNCHANGED (not an error).
+#
+# .publicignore matching -- ported (not sourced) from
+# skills/mirror-public/scripts/mirror.sh's `_publicignore_rule_for` helper:
+# directory-prefix match for trailing-"/" lines, glob match against the full
+# relative path and the basename for everything else, skipping comments,
+# blank lines, and "+"-prefixed include lines (which never block anything).
+# This is a deliberate, flagged duplication of matching logic -- not a
+# `source` of mirror.sh, which unconditionally loads config.json and
+# requires rsync near the top of its execution, neither of which this
+# lighter, dependency-free check needs. Same tradeoff mark-merged.sh's own
+# header comment already documents and accepts for its COPY_SET extraction.
+#
+# A ticket is "fully blocklisted" iff EVERY file in its derived touched-file
+# list matches SOME .publicignore pattern. Partial coverage leaves the
+# ticket unchanged, no error (mirrors AC5's "no files fully covered"
+# language, applied to the blocklist side).
+#
+# Precedence / mismatch logging (AC4, this script's half of it): a ticket
+# already at `status: Publicized` that is found fully blocklisted still gets
+# overwritten to `Privatized` (Privatized wins -- the static, always-knowable
+# check takes precedence per the story's AC4 and
+# templates/SCRUM_BOARD_SCHEMA.md's "Publicized / Privatized / Deployed
+# Lifecycle Relationship" section), but the contradiction is logged to
+# project/logs/events.json as `event: publicized_privatized_mismatch` (same
+# array-of-objects convention already used by session_start/etc., and the
+# same event name E51_S03_T02's own task description documents for the
+# reverse-direction mismatch) so it's flagged for investigation rather than
+# silently resolved. The read-modify-write against events.json is wrapped in
+# scripts/with-lock.sh since multiple sessions may be writing to it
+# concurrently.
+#
+# A ticket already at `status: Privatized` is skipped without error
+# (idempotency) -- same defensive-skip convention mark-merged.sh uses for
+# its own terminal status.
+#
+# Output contract (stdout, single line) -- consumed by /close-story's prose
+# steps to decide whether to report a Privatized ticket:
+#   PRIVATIZED   status was written (or already Privatized -- treated the
+#                same by the caller: either way the ticket ends this call at
+#                status Privatized)
+#   UNCHANGED    ticket left as-is (zero matched commits, partial coverage,
+#                or already Privatized with nothing further to do)
+#
+# Exit codes:
+#   0   success (covers both PRIVATIZED and UNCHANGED outcomes)
+#   1   error (bad usage, missing file, or a status-write failure)
+# ---------------------------------------------------------------------------
+
+set -euo pipefail
+IFS=$'\n\t'
+
+die() {
+  printf 'check-privatized.sh: error: %s\n' "$*" >&2
+  exit 1
+}
+
+log() {
+  printf 'check-privatized.sh: %s\n' "$*" >&2
+}
+
+usage() {
+  cat <<'EOF'
+Usage: check-privatized.sh <id> <board-file-path>
+
+Static .publicignore membership check for a single ticket (task or story).
+Prints PRIVATIZED or UNCHANGED to stdout. See script header for full
+semantics.
+EOF
+}
+
+if [ $# -ne 2 ]; then
+  usage >&2
+  die "expected exactly 2 arguments, got $#"
+fi
+
+ID="$1"
+BOARD_FILE="$2"
+
+[ -f "$BOARD_FILE" ] || die "board file not found: $BOARD_FILE"
+
+# -----------------------------------------------------------------------------
+# Locate script + repo root (same symlink-resolution + repo-root derivation
+# pattern as mark-merged.sh, so this script behaves identically whether
+# invoked directly or via a symlink).
+# -----------------------------------------------------------------------------
+
+SCRIPT_PATH="${BASH_SOURCE[0]}"
+while [ -h "$SCRIPT_PATH" ]; do
+  LINK_TARGET="$(readlink "$SCRIPT_PATH")"
+  case "$LINK_TARGET" in
+    /*) SCRIPT_PATH="$LINK_TARGET" ;;
+    *)  SCRIPT_PATH="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)/$LINK_TARGET" ;;
+  esac
+done
+SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+
+REPO_ROOT="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || true)"
+[ -n "$REPO_ROOT" ] || die "could not locate repo root (git rev-parse failed from $SCRIPT_DIR)"
+
+PUBLICIGNORE="$REPO_ROOT/.publicignore"
+[ -f "$PUBLICIGNORE" ] || die ".publicignore not found at $PUBLICIGNORE"
+
+WITH_LOCK_SCRIPT="$REPO_ROOT/scripts/with-lock.sh"
+UPDATE_FRONTMATTER_SCRIPT="$REPO_ROOT/skills/close-story/scripts/update-task-frontmatter.sh"
+EVENTS_FILE="$REPO_ROOT/project/logs/events.json"
+
+[ -f "$WITH_LOCK_SCRIPT" ] || die "expected script not found: $WITH_LOCK_SCRIPT"
+[ -f "$UPDATE_FRONTMATTER_SCRIPT" ] || die "expected script not found: $UPDATE_FRONTMATTER_SCRIPT"
+
+# -----------------------------------------------------------------------------
+# Frontmatter field reader -- same "line == ---" boundary-detection style
+# already used by update-task-frontmatter.sh / mark-merged.sh.
+# -----------------------------------------------------------------------------
+
+read_frontmatter_field() {
+  local file="$1" key="$2"
+  awk -v key="$key" '
+    NR==1 && $0=="---" { infm=1; next }
+    infm && $0=="---" { exit }
+    infm && $0 ~ ("^" key ":") {
+      sub("^" key ":[ \t]*", "", $0)
+      print $0
+      exit
+    }
+  ' "$file"
+}
+
+trim() {
+  local s="$1"
+  s="${s#"${s%%[![:space:]]*}"}"
+  s="${s%"${s##*[![:space:]]}"}"
+  s="${s%\"}"; s="${s#\"}"
+  s="${s%\'}"; s="${s#\'}"
+  printf '%s' "$s"
+}
+
+CURRENT_STATUS="$(trim "$(read_frontmatter_field "$BOARD_FILE" "status")")"
+
+if [ "$CURRENT_STATUS" = "Privatized" ]; then
+  log "$ID: already Privatized -- skip (idempotent no-op)"
+  echo "UNCHANGED"
+  exit 0
+fi
+
+# -----------------------------------------------------------------------------
+# Touched-file derivation -- identical technique to mark-merged.sh.
+# -----------------------------------------------------------------------------
+
+commits_for_ticket() {
+  local id="$1"
+  git -C "$REPO_ROOT" log --all --no-merges --extended-regexp \
+    --grep="${id}([^0-9_]|\$)" --pretty=format:'%H' 2>/dev/null || true
+}
+
+commit_files() {
+  local sha="$1"
+  if git -C "$REPO_ROOT" rev-parse --verify -q "${sha}~1" >/dev/null 2>&1; then
+    git -C "$REPO_ROOT" diff --name-only "${sha}~1..${sha}" 2>/dev/null || true
+  else
+    git -C "$REPO_ROOT" diff-tree --no-commit-id --name-only -r "$sha" 2>/dev/null || true
+  fi
+}
+
+collect_touched_files() {
+  local id="$1"
+  local shas sha
+  shas="$(commits_for_ticket "$id")"
+  [ -n "$shas" ] || return 0
+  while IFS= read -r sha; do
+    [ -n "$sha" ] || continue
+    commit_files "$sha"
+  done <<< "$shas" | sort -u
+}
+
+TOUCHED="$(collect_touched_files "$ID")"
+
+if [ -z "$TOUCHED" ]; then
+  log "$ID: zero matched EST-tagged commits -- left unchanged"
+  echo "UNCHANGED"
+  exit 0
+fi
+
+# -----------------------------------------------------------------------------
+# .publicignore matching -- ported from mirror.sh's _publicignore_rule_for.
+#
+# Prints the matching .publicignore line and returns 0 on a match; returns 1
+# with no output if nothing matched. Directory-prefix match for trailing-"/"
+# lines, glob match against the full relative path and the basename for
+# everything else, skipping comments/blank lines/"+"-prefixed include lines.
+# -----------------------------------------------------------------------------
+
+_publicignore_rule_for() {
+  local rel_path="$1" line pattern base dirpat
+  base="$(basename "$rel_path")"
+  while IFS= read -r line || [ -n "$line" ]; do
+    case "$line" in
+      ''|'#'*|'+'*) continue ;;
+    esac
+    pattern="$line"
+    case "$pattern" in
+      '- '*) pattern="${pattern#- }" ;;
+    esac
+    [ -n "$pattern" ] || continue
+    case "$pattern" in
+      */)
+        dirpat="${pattern%/}"
+        case "$rel_path" in
+          "$dirpat"/*)
+            printf '%s\n' "$line"
+            return 0
+            ;;
+        esac
+        ;;
+      *)
+        case "$rel_path" in
+          $pattern)
+            printf '%s\n' "$line"
+            return 0
+            ;;
+        esac
+        case "$base" in
+          $pattern)
+            printf '%s\n' "$line"
+            return 0
+            ;;
+        esac
+        ;;
+    esac
+  done < "$PUBLICIGNORE"
+  return 1
+}
+
+# True (0) iff every line of $1 (touched files, newline-separated) matches
+# some .publicignore pattern.
+is_fully_blocklisted() {
+  local touched="$1"
+  local line
+  while IFS= read -r line; do
+    [ -n "$line" ] || continue
+    _publicignore_rule_for "$line" >/dev/null || return 1
+  done <<< "$touched"
+  return 0
+}
+
+if ! is_fully_blocklisted "$TOUCHED"; then
+  log "$ID: not fully covered by .publicignore -- left unchanged"
+  echo "UNCHANGED"
+  exit 0
+fi
+
+# -----------------------------------------------------------------------------
+# Fully blocklisted. Precedence check against a contradictory Publicized
+# status (AC4) before writing.
+# -----------------------------------------------------------------------------
+
+if [ "$CURRENT_STATUS" = "Publicized" ]; then
+  log "$ID: WARNING -- ticket is status: Publicized but every touched file matches .publicignore; Privatized takes precedence (overwriting), logging mismatch"
+
+  TOUCHED_JSON_LIST="$(printf '%s\n' "$TOUCHED" | awk '
+    BEGIN { printf "[" ; first=1 }
+    { if (!first) printf ","; printf "\"%s\"", $0; first=0 }
+    END { printf "]" }
+  ')"
+  [ -n "$TOUCHED_JSON_LIST" ] || TOUCHED_JSON_LIST="[]"
+
+  MISMATCH_EVENT=$(printf '{"event": "publicized_privatized_mismatch", "agent": "developer", "id": "%s", "file": "%s", "touched_files": %s, "date": "%s"}' \
+    "$ID" "$BOARD_FILE" "$TOUCHED_JSON_LIST" "$(date -u +%Y-%m-%dT%H:%M:%SZ)")
+
+  if [ -f "$EVENTS_FILE" ]; then
+    "$WITH_LOCK_SCRIPT" "$EVENTS_FILE" -- bash -c '
+      set -euo pipefail
+      events_file="$1"
+      new_event="$2"
+      tmp="$(mktemp)"
+      if command -v python3 >/dev/null 2>&1; then
+        python3 -c "
+import json, sys
+path = sys.argv[1]
+new_event = json.loads(sys.argv[2])
+with open(path) as f:
+    data = json.load(f)
+data.append(new_event)
+with open(path, \"w\") as f:
+    json.dump(data, f, indent=2)
+    f.write(\"\n\")
+" "$events_file" "$new_event"
+      else
+        echo "check-privatized.sh: python3 not available -- could not append mismatch event" >&2
+        rm -f "$tmp"
+        exit 1
+      fi
+    ' _ "$EVENTS_FILE" "$MISMATCH_EVENT" || log "WARNING: failed to log publicized_privatized_mismatch event for $ID (continuing with status overwrite)"
+  else
+    log "WARNING: $EVENTS_FILE not found -- could not log publicized_privatized_mismatch event"
+  fi
+fi
+
+log "$ID: fully covered by .publicignore -- writing status: Privatized ($BOARD_FILE)"
+if ! "$WITH_LOCK_SCRIPT" "$BOARD_FILE" -- bash "$UPDATE_FRONTMATTER_SCRIPT" "$BOARD_FILE" status Privatized; then
+  die "failed to write status: Privatized for $ID ($BOARD_FILE)"
+fi
+
+echo "PRIVATIZED"
+exit 0

package/skills/commit/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: commit
+name: j:commit
 description: Commit implemented epic, story, or task work using the EST naming convention. Also handles user-action prerequisites and new-epic boundaries. Use after completing any EST work item.
 keywords:
   - commit
@@ -36,7 +36,17 @@ If `--inline` is absent **and** `JENGA_COMMIT_INLINE` is not set (or is not `1`)
 
 If no epic, task, or story has been implemented, exit with the message: "No implementation to commit."
 
-1. **Reconcile first** — Invoke the `/reconcile` skill before any other action, so the board is never committed in a drifted state.
+1. **Reconcile first, scoped to this commit** — Invoke the `/reconcile` skill before any other action, so the board is never committed in a drifted state.
+   - **Determine the scope to pass** (in order):
+     1. If `/commit` was invoked with an explicit epic/story/task id argument (e.g. `/commit E46`, `/commit E17_S04_T02`), use that id.
+     2. Otherwise, if the calling context already identifies a single task/story/epic just completed (e.g. a developer or tester agent's sender object naming `task_id`/`story_id`/`epic_id`, or a `/do` invocation for one task), use that id.
+     3. Otherwise, derive it from what's staged: run `git diff --cached --name-only` and filter to paths under `project/board/epics/`, `project/board/stories/`, and `project/board/tasks/`. Extract the id each matched filename encodes.
+        - If every extracted id shares a single common story-or-narrower ancestor (all belong to one story's own file plus any of its own tasks' files, or are all exactly one task's own file, or are all exactly one epic's own file with nothing narrower staged), use that single most-specific id (story/task id if present, else the epic id) as the scope.
+        - If matched ids span more than one distinct story, or more than one distinct epic, this case does not resolve — do not guess between them; fall through to case 4.
+        - **If no board files at all are staged, skip `/reconcile` entirely — do not fall through to case 4.** A commit that touches no board file cannot itself commit board drift, so there is nothing for a pre-commit reconcile to protect against; running a full unscoped scan here would be pure waste, not a safety net. This is distinct from the multi-item case immediately above, which still falls through to case 4 since board files genuinely are changing there.
+     4. Otherwise — no argument, no sender context, and staged board files span more than one distinct story or epic — fall back to unscoped `/reconcile` (full board), unchanged from prior behavior.
+   - **Invoke** `/reconcile <scope>` when a scope was determined in cases 1-3, unscoped `/reconcile` on the case-4 fallback, or skip the reconcile step entirely per case 3's no-board-files-staged outcome. Do not re-derive or duplicate `/reconcile`'s own default-scope-to-epic expansion here — passing a bare story or task id through is sufficient; `/reconcile` itself resolves that to the containing epic.
+   - **If `/reconcile` was skipped** (case 3's no-board-files-staged outcome) — continue silently to the next step, exactly as the no-drift outcome below.
    - **If reconcile detects and corrects drift** — inform the user what changed (e.g. demoted/promoted statuses, merged orphaned worktrees, cleaned `todo.md` entries) before proceeding.
    - **If reconcile finds no drift** — continue silently to the next step.
 

package/skills/continue/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: continue
+name: j:continue
 description: Check project status across PROJECT_SUMMARY.md, epics, and stories to determine what should be done next. Reports "All done!" if everything is complete.
 keywords:
   - continue

package/skills/deep-dive/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: deep-dive
+name: j:deep-dive
 description: >
   Multi-phase investigation workflow. The scrum-master orchestrates information
   gathering, interactive brainstorming, critical scrutiny, and solution assessment

package/skills/dev-done/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: j:dev-done
+description: Commit the current work and immediately sync it into the .claude/ and .agents/ mirrors. Shortcut that chains /commit followed by /self-sync.
+keywords:
+  - dev done
+  - commit and sync
+  - commit and mirror
+  - done syncing
+examples:
+  - "dev-done E42_S04_T01"
+  - "commit this and sync the mirrors"
+---
+
+# Dev-Done — Commit, then Sync the Mirrors
+
+Chains `/commit <scope-id>` and `/self-sync`, the same "convenience shortcut" pattern `skills/lgtm/SKILL.md`
+uses for `/commit` + `/continue` — applied here to the commit -> mirror-sync sequence instead of the
+commit -> next-task sequence. Useful right after implementing a root-level framework change
+(`skills/`, `agents/`, `hooks/`, `scripts/`, `templates/`, `settings.json`), so the `.claude/` and
+`.agents/` mirrors never sit stale waiting on a manual `/self-sync` call.
+
+The deterministic decision of whether `/commit` halted early (nothing to commit) or completed
+normally lives in `skills/dev-done/scripts/classify-commit-outcome.sh`, not inline here — see that
+script's header for the exact contract.
+
+## Instructions
+
+1. Invoke the `/commit` skill with whatever scope-id argument `/dev-done` itself was given (e.g.
+   `/dev-done E42_S04_T01` invokes `/commit E42_S04_T01`) — the same EST scope-id argument contract
+   `/commit` already accepts (epic, story, or task id; see `skills/commit/SKILL.md`). Capture its full
+   output text.
+
+2. Pass the captured output to the classifier script:
+   ```
+   skills/dev-done/scripts/classify-commit-outcome.sh <<< "$COMMIT_OUTPUT"
+   ```
+
+3. If the script exits `1` (HALT): print its stdout — the exact message `No implementation to
+   commit.` — to the user, and stop. Do **not** invoke `/self-sync`.
+
+4. If the script exits `0` (PROCEED): invoke the `/self-sync` skill and wait for it to finish. This
+   happens regardless of whether `/commit` reported drift or doc-sync findings along the way — those
+   are informational, not blocking (see `skills/commit/SKILL.md`).
+
+5. Report both steps' output to the user in sequence — the commit result first, then the self-sync
+   summary.

package/skills/dev-done/scripts/classify-commit-outcome.sh

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+# ---------------------------------------------------------------------------
+# skills/dev-done/scripts/classify-commit-outcome.sh
+#
+# Deterministic classifier backing `/dev-done` (story E42_S04, task
+# E42_S04_T01). `/dev-done` chains `/commit <scope-id>` then `/self-sync`,
+# but must NOT proceed to `/self-sync` when `/commit` halted early because
+# there was nothing to commit. Per CLAUDE.md's "Skill Implementation
+# Principle — Scripts Over Inline Logic", that halt-vs-proceed check is a
+# deterministic, repeatable text match — it does not belong as inline
+# conditional logic in `skills/dev-done/SKILL.md`, so it lives here instead,
+# the same way `skills/self-sync/SKILL.md` delegates its own filesystem work
+# to `skills/self-sync/scripts/run.js` rather than inlining it.
+#
+# `/commit` and `/self-sync` are themselves agent-executed skills, not plain
+# executables — this script never shells out to invoke either one. It only
+# classifies text that the calling agent already captured from `/commit`'s
+# output. Invoking `/commit` and `/self-sync` remains `SKILL.md`'s job.
+#
+# ---------------------------------------------------------------------------
+# WHAT IT MATCHES
+# ---------------------------------------------------------------------------
+# `skills/commit/SKILL.md`'s Instructions section states, verbatim:
+#
+#   "If no epic, task, or story has been implemented, exit with the message:
+#   "No implementation to commit.""
+#
+# That exact sentence — "No implementation to commit." — is the ONLY halt
+# signal this script recognizes. If a future edit to `skills/commit/SKILL.md`
+# changes that wording, this script's match must be updated to match, or it
+# will silently stop recognizing the halt case (see Dependencies & Risks in
+# the task's execution plan).
+#
+# ---------------------------------------------------------------------------
+# INVOCATION
+# ---------------------------------------------------------------------------
+#   classify-commit-outcome.sh [<captured-commit-output>]
+#
+# The text `/commit` produced is passed either as the single argument, or
+# (when no argument is given) read from stdin in full, e.g.:
+#
+#   skills/dev-done/scripts/classify-commit-outcome.sh <<< "$COMMIT_OUTPUT"
+#   printf '%s' "$COMMIT_OUTPUT" | skills/dev-done/scripts/classify-commit-outcome.sh
+#
+# ---------------------------------------------------------------------------
+# OUTPUT CONTRACT (stdout, single line, nothing else)
+# ---------------------------------------------------------------------------
+#   HALT case      stdout is the exact literal message "No implementation to
+#                  commit." — the calling agent relays this stdout verbatim
+#                  to the user and does NOT invoke `/self-sync`.
+#   PROCEED case    stdout is the literal token "PROCEED" — the calling
+#                  agent invokes `/self-sync` next.
+#
+# ---------------------------------------------------------------------------
+# EXIT CODES
+# ---------------------------------------------------------------------------
+#   0   PROCEED — `/commit` completed normally (regardless of whether it
+#       reported drift or doc-sync findings along the way); stdout is
+#       "PROCEED".
+#   1   HALT — `/commit` halted early with the exact "No implementation to
+#       commit." message; stdout is that exact message.
+#   2   Usage/environment error (e.g. no input at all — neither an argument
+#       nor anything on stdin); nothing meaningful on stdout, an error on
+#       stderr.
+# ---------------------------------------------------------------------------
+
+set -euo pipefail
+
+HALT_MESSAGE="No implementation to commit."
+
+if [ "$#" -gt 1 ]; then
+  echo "Usage: $(basename "$0") [<captured-commit-output>]" >&2
+  echo "  (or pipe the captured output on stdin with no argument)" >&2
+  exit 2
+fi
+
+if [ "$#" -eq 1 ]; then
+  INPUT="$1"
+else
+  # No argument — read the full captured output from stdin.
+  if [ -t 0 ]; then
+    echo "ERROR: no argument given and stdin is a terminal — nothing to classify" >&2
+    exit 2
+  fi
+  INPUT="$(cat)"
+fi
+
+if [ -z "$INPUT" ]; then
+  echo "ERROR: no commit output provided to classify" >&2
+  exit 2
+fi
+
+# Trim leading/trailing whitespace from the whole input for the exact-match case.
+TRIMMED="$(printf '%s' "$INPUT" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')"
+
+if [ "$TRIMMED" = "$HALT_MESSAGE" ]; then
+  printf '%s\n' "$HALT_MESSAGE"
+  exit 1
+fi
+
+# Also match the halt message appearing as its own standalone line anywhere
+# in a longer captured response (e.g. wrapped in surrounding agent prose),
+# since the calling agent's captured "output text" is free-form, not a
+# guaranteed exact-equals string.
+while IFS= read -r line; do
+  LINE_TRIMMED="$(printf '%s' "$line" | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')"
+  if [ "$LINE_TRIMMED" = "$HALT_MESSAGE" ]; then
+    printf '%s\n' "$HALT_MESSAGE"
+    exit 1
+  fi
+done <<< "$INPUT"
+
+printf 'PROCEED\n'
+exit 0

package/skills/distribute/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: distribute
+name: j:distribute
 description: Distribute Jenga AI framework files from this private monorepo to one or more consuming projects via the local filesystem. Manages release type selection, version bumping, dry-run preview, per-target file copy, and a post-distribution git commit.
 keywords:
   - distribute