@jenga-ai/agent 1.3.0 → 3.0.0

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

@@ -0,0 +1,345 @@
+#!/usr/bin/env bash
+# ---------------------------------------------------------------------------
+# skills/j-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/j-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/{close-story → j-close-story}/scripts/check-story-closeable.sh

@@ -22,7 +22,7 @@ usage() {
 }
 
 # Locate the project root relative to this script's location.
-# Script lives at: skills/close-story/scripts/check-story-closeable.sh
+# Script lives at: skills/j-close-story/scripts/check-story-closeable.sh
 # Project root is three levels up (skills/ → repo root).
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"

package/skills/{close-story → j-close-story}/scripts/extract-task-diff-stats.sh

@@ -12,7 +12,7 @@
 #
 # For bundle tasks (a single commit covers multiple task IDs), each task that
 # matches the commit receives the full bundle stats — this is the "full credit"
-# attribution model. See skills/close-story/SKILL.md for the rationale.
+# attribution model. See skills/j-close-story/SKILL.md for the rationale.
 #
 # Exit codes:
 #   0 — success (even when no commits are found; outputs 0 values)

package/skills/{commit → j-commit}/SKILL.md

@@ -1,19 +1,26 @@
 ---
-name: 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.
+name: j.commit
+description: Polyfill alias of the commit skill under a collision-safe directory name. Identical behavior to /commit — 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. Use when the bare /commit form is shadowed by another tool's own built-in command of the same name.
 keywords:
   - commit
   - save
   - git commit
   - done
   - push
+  - j-commit
+  - polyfill
 examples:
   - "commit this work"
   - "save my changes"
+  - "j-commit"
 ---
 
 # Commit — Commit Completed Work
 
+This skill is a literal-directory-name duplicate of `skills/commit/`. It exists so that `/j-commit` (and `j.j-commit`) give a guaranteed-unshadowed way to reach the same flow as `/commit`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/commit` alias (Claude Code's native skill resolution is a literal-string, directory-name-based match — see `docs/skill-authoring.md`'s "Invocation Convention").
+
+This file is generated/synced by `scripts/generate-j-alias.sh commit` from `skills/commit/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 ## Inline Mode (called by /do for inline-scoped tasks)
 
 When invoked with the `--inline` flag OR when the environment variable `JENGA_COMMIT_INLINE=1` is set, execute inline mode:

package/skills/j-continue/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: j.continue
+description: Polyfill alias of the continue skill under a collision-safe directory name. Identical behavior to /continue — Check project status across PROJECT_SUMMARY.md, epics, and stories to determine what should be done next. Reports "All done!" if everything is complete. Use when the bare /continue form is shadowed by another tool's own built-in command of the same name.
+keywords:
+  - continue
+  - next
+  - proceed
+  - what's next
+  - status
+  - j-continue
+  - polyfill
+examples:
+  - "what should I do next?"
+  - "continue with the project"
+  - "j-continue"
+---
+
+# Continue — Pick Up the Next Work Item
+
+This skill is a literal-directory-name duplicate of `skills/continue/`. It exists so that `/j-continue` (and `j.j-continue`) give a guaranteed-unshadowed way to reach the same flow as `/continue`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/continue` alias (Claude Code's native skill resolution is a literal-string, directory-name-based match — see `docs/skill-authoring.md`'s "Invocation Convention").
+
+This file is generated/synced by `scripts/generate-j-alias.sh continue` from `skills/continue/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
+## Instructions
+
+1. **Check `project/PROJECT_SUMMARY.md`** — Determine if there is outstanding work at the project level.
+
+2. **Check `project/epics/`** — If the project summary is done, check if any epics have remaining work.
+
+3. **Check `project/stories/`** — If epics are done, check if any stories have remaining work.
+
+   **Important:** Always check story status within an epic even if the epic itself is marked as done.
+
+4. **If everything is complete** — Respond with: "All done! 🎉"
+
+5. **Otherwise** — Begin work on the next incomplete item.

package/skills/{deep-dive → j-deep-dive}/SKILL.md

@@ -1,12 +1,6 @@
 ---
-name: deep-dive
-description: >
-  Multi-phase investigation workflow. The scrum-master orchestrates information
-  gathering, interactive brainstorming, critical scrutiny, and solution assessment
-  to produce a refined, well-considered output document. Use when a request needs
-  thorough analysis before committing to a plan. Triggers on phrases like
-  "deep dive", "investigate thoroughly", "think this through properly",
-  "analyze this in depth", or "I want a thorough analysis of".
+name: j.deep-dive
+description: Polyfill alias of the deep-dive skill under a collision-safe directory name. Identical behavior to /deep-dive — >. Use when the bare /deep-dive form is shadowed by another tool's own built-in command of the same name.
 metadata:
   prefered_agent: scrum_master
 keywords:
@@ -14,15 +8,22 @@ keywords:
   - "investigate"
   - "analyze thoroughly"
   - "think through"
+  - j-deep-dive
+  - polyfill
 examples:
   - "deep dive on this idea"
   - "let's think through this properly"
   - "I want a thorough analysis of this feature"
   - "investigate this proposal in depth"
+  - "j-deep-dive"
 ---
 
 # /deep-dive — Deep Investigation Workflow
 
+This skill is a literal-directory-name duplicate of `skills/deep-dive/`. It exists so that `/j-deep-dive` (and `j.j-deep-dive`) give a guaranteed-unshadowed way to reach the same flow as `/deep-dive`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/deep-dive` alias (Claude Code's native skill resolution is a literal-string, directory-name-based match — see `docs/skill-authoring.md`'s "Invocation Convention").
+
+This file is generated/synced by `scripts/generate-j-alias.sh deep-dive` from `skills/deep-dive/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 ## Overview
 
 A multi-phase workflow that takes a user's request through structured investigation,

package/skills/{dev-done → j-dev-done}/SKILL.md

@@ -1,18 +1,25 @@
 ---
-name: 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.
+name: j.dev-done
+description: Polyfill alias of the dev-done skill under a collision-safe directory name. Identical behavior to /dev-done — Commit the current work and immediately sync it into the .claude/ and .agents/ mirrors. Shortcut that chains /commit followed by /self-sync. Use when the bare /dev-done form is shadowed by another tool's own built-in command of the same name.
 keywords:
   - dev done
   - commit and sync
   - commit and mirror
   - done syncing
+  - j-dev-done
+  - polyfill
 examples:
   - "dev-done E42_S04_T01"
   - "commit this and sync the mirrors"
+  - "j-dev-done"
 ---
 
 # Dev-Done — Commit, then Sync the Mirrors
 
+This skill is a literal-directory-name duplicate of `skills/dev-done/`. It exists so that `/j-dev-done` (and `j.j-dev-done`) give a guaranteed-unshadowed way to reach the same flow as `/dev-done`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/dev-done` alias (Claude Code's native skill resolution is a literal-string, directory-name-based match — see `docs/skill-authoring.md`'s "Invocation Convention").
+
+This file is generated/synced by `scripts/generate-j-alias.sh dev-done` from `skills/dev-done/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 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
@@ -20,7 +27,7 @@ commit -> next-task sequence. Useful right after implementing a root-level frame
 `.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
+normally lives in `skills/j-dev-done/scripts/classify-commit-outcome.sh`, not inline here — see that
 script's header for the exact contract.
 
 ## Instructions
@@ -32,7 +39,7 @@ script's header for the exact contract.
 
 2. Pass the captured output to the classifier script:
    ```
-   skills/dev-done/scripts/classify-commit-outcome.sh <<< "$COMMIT_OUTPUT"
+   skills/j-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

package/skills/{dev-done → j-dev-done}/scripts/classify-commit-outcome.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/dev-done/scripts/classify-commit-outcome.sh
+# skills/j-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`,
@@ -8,7 +8,7 @@
 # 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,
+# conditional logic in `skills/j-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.
 #
@@ -39,8 +39,8 @@
 # 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
+#   skills/j-dev-done/scripts/classify-commit-outcome.sh <<< "$COMMIT_OUTPUT"
+#   printf '%s' "$COMMIT_OUTPUT" | skills/j-dev-done/scripts/classify-commit-outcome.sh
 #
 # ---------------------------------------------------------------------------
 # OUTPUT CONTRACT (stdout, single line, nothing else)

package/skills/{distribute → j-distribute}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: 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.
+name: j.distribute
+description: Polyfill alias of the distribute skill under a collision-safe directory name. Identical behavior to /distribute — 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. Use when the bare /distribute form is shadowed by another tool's own built-in command of the same name.
 keywords:
   - distribute
   - private distribution
@@ -8,14 +8,21 @@ keywords:
   - framework update
   - version bump
   - distribute to projects
+  - j-distribute
+  - polyfill
 examples:
   - "/distribute"
   - "/distribute /path/to/consuming-project"
   - "/distribute --dry-run"
+  - "j-distribute"
 ---
 
 # Distribute
 
+This skill is a literal-directory-name duplicate of `skills/distribute/`. It exists so that `/j-distribute` (and `j.j-distribute`) give a guaranteed-unshadowed way to reach the same flow as `/distribute`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/distribute` alias (Claude Code's native skill resolution is a literal-string, directory-name-based match — see `docs/skill-authoring.md`'s "Invocation Convention").
+
+This file is generated/synced by `scripts/generate-j-alias.sh distribute` from `skills/distribute/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 Copies Jenga AI framework files from this monorepo to all active consuming projects registered in `distribute.config.json`. Manages the full version lifecycle: release type selection, `package.json` version bump, dry-run preview, per-target file copy, and a final git commit of the version bump.
 
 Distinct from `/self-sync` (which mirrors root → in-repo `.claude/.agents/`) and `/mirror-public` (which syncs to the public GitHub repo). Do not call either of those skills from within this flow.
@@ -60,7 +67,7 @@ Read `distribute.config.json`.
 For each entry in `targets`:
 - If `active` is `false`: print `Skipping <name> — inactive.` Do not include it in the distribution run.
 - If the `path` does not exist on disk: print `Skipping <name> — path not found: <path>.` Do not include it in the distribution run.
-- If release type is `amend`: run `bash skills/distribute/scripts/check-version.sh <path>`.
+- If release type is `amend`: run `bash skills/j-distribute/scripts/check-version.sh <path>`.
   - Exit 0 → include the target.
   - Exit 1 → print `Skipping <name> — already up to date.` Do not include it in the distribution run (record it in the final report as "already up to date").
   - Exit 2 → print `Skipping <name> — invalid path or config.` Do not include it.
@@ -87,7 +94,7 @@ On success, read the new version from `package.json` and print: `Version bumped
 For each eligible target (from Step 3), run:
 
 ```bash
-bash skills/distribute/scripts/distribute-changes.sh <project_path> --dry-run
+bash skills/j-distribute/scripts/distribute-changes.sh <project_path> --dry-run
 ```
 
 Display the full output for each target. Then ask the user:
@@ -101,7 +108,7 @@ Wait for confirmation. If the user does not confirm, halt without making any cha
 For each eligible target in sequence:
 
 ```bash
-bash skills/distribute/scripts/distribute-changes.sh <project_path>
+bash skills/j-distribute/scripts/distribute-changes.sh <project_path>
 ```
 
 Record the exit code and any output. If a target fails (non-zero exit), record the failure and continue to the next target. Do not abort the run on partial failure.
@@ -129,7 +136,7 @@ Skip this step for `amend`. Skip this step if no targets succeeded in Step 6.
 Call:
 
 ```bash
-bash skills/distribute/scripts/commit-version-bump.sh
+bash skills/j-distribute/scripts/commit-version-bump.sh
 ```
 
 Report the resulting commit SHA to the user.
@@ -144,15 +151,15 @@ Do not invoke `/self-sync` or `/mirror-public` at any point in this flow. They a
 
 | Script | Purpose |
 |--------|---------|
-| `skills/distribute/scripts/distribute-changes.sh <path> [--dry-run]` | Copy framework files to a single consuming project |
-| `skills/distribute/scripts/commit-version-bump.sh` | Commit the `package.json` version bump |
-| `skills/distribute/scripts/check-version.sh <path>` | Amend mode: exits 0 if target needs update, 1 if up to date, 2 if invalid |
+| `skills/j-distribute/scripts/distribute-changes.sh <path> [--dry-run]` | Copy framework files to a single consuming project |
+| `skills/j-distribute/scripts/commit-version-bump.sh` | Commit the `package.json` version bump |
+| `skills/j-distribute/scripts/check-version.sh <path>` | Amend mode: exits 0 if target needs update, 1 if up to date, 2 if invalid |
 
 ## Config
 
 `distribute.config.json` at the repo root is the registry of consuming projects.
 
-Schema reference: `skills/distribute/CONFIG_SCHEMA.md`
+Schema reference: `skills/j-distribute/CONFIG_SCHEMA.md`
 
 Each target entry:
 

package/skills/{distribute → j-distribute}/scripts/distribute-changes.sh

@@ -45,7 +45,7 @@ dry_run() { echo "[DRY RUN] $*"; }
 
 # ---------------------------------------------------------------------------
 # Resolve monorepo root from this script's location.
-# Script lives at: skills/distribute/scripts/distribute-changes.sh
+# Script lives at: skills/j-distribute/scripts/distribute-changes.sh
 # Repo root is three levels up.
 # ---------------------------------------------------------------------------