@jenga-ai/agent 3.2.0 → 3.5.0

package/skills/j-dashboard-share/scripts/upload-snapshot.sh

@@ -0,0 +1,173 @@
+#!/usr/bin/env bash
+# -----------------------------------------------------------------------------
+# skills/j-dashboard-share/scripts/upload-snapshot.sh
+#
+# Uploads a local dashboard snapshot HTML file (as produced by j-dashboard's
+# `scripts/snapshot.sh`) to a configured rclone remote via `rclone copyto`, at
+# a templated, Drive-side (remote-side) destination path:
+#
+#   JengaAI/<repo-directory-name>/<datetime>-board-snapshot.html
+#
+#   - <repo-directory-name> is the basename of the repository root, derived
+#     via `basename "$(git rev-parse --show-toplevel)"` — never hardcoded to
+#     any specific project.
+#   - <datetime> is the actual UTC run time, formatted `%Y%m%dT%H%M%SZ`
+#     (compact ISO 8601-ish, sortable, filesystem/URL-safe).
+#
+# This destination path is entirely independent of the LOCAL snapshot
+# filename (whatever `snapshot.sh --out` wrote it as) — this script only
+# reads the local file's bytes and uploads them under its own remote-side
+# name.
+#
+# Before attempting any upload, this script verifies the target rclone
+# remote is actually configured (present in `rclone listremotes`). If it is
+# not, this script does NOT attempt the upload and does NOT let rclone
+# surface its own raw error — it dies with an actionable message pointing
+# the user at `j.cloud-connect` (E60_S01) to configure a remote first.
+#
+# HARD SCOPE BOUNDARY: this script uploads ONLY. It never invokes
+# `rclone link` or any other link-creating/sharing subcommand, anywhere in
+# its logic — that is a deliberate, separate, manual action reserved for the
+# user (see E47_S05's story decision). Do not add one.
+#
+# This script does not create or wire up the `j-dashboard-share` skill
+# itself (SKILL.md) — that is a separate task (E47_S05_T02). It assumes a
+# remote has already been configured via `j.cloud-connect`
+# (skills/j-cloud-connect/scripts/{install-rclone.sh,configure-backend.sh},
+# E60_S01) and that `rclone` is already on PATH.
+#
+# Invoked via `bash`, not executed directly: this script intentionally ships
+# without the executable bit, matching the convention already documented in
+# skills/j-cloud-connect/scripts/install-rclone.sh and
+# skills/j-dashboard/scripts/resolve-app-dir.sh. Whatever wires this into the
+# j-dashboard-share skill (E47_S05_T02) should invoke it as
+# `bash skills/j-dashboard-share/scripts/upload-snapshot.sh`.
+#
+# Usage:
+#   upload-snapshot.sh --file <local-snapshot-path> --remote <remote-name>
+#
+#   --file <path>     Path to the local snapshot HTML file to upload (e.g.
+#                      the output of `j.dashboard --snapshot`). Must exist
+#                      and be non-empty.
+#   --remote <name>   Name of an already-configured rclone remote (without a
+#                      trailing colon), e.g. `gdrive`. Checked against
+#                      `rclone listremotes` before any upload is attempted.
+#
+# Exit codes:
+#   0  Upload succeeded. The full remote destination path is printed on
+#      stdout as the last line.
+#   1  Any failure: bad arguments, missing/empty local file, `rclone` not on
+#      PATH, not inside a git repository, the target remote is not
+#      configured (points the user at `j.cloud-connect`), or `rclone copyto`
+#      itself failed. A human-readable reason is always printed to stderr.
+# -----------------------------------------------------------------------------
+
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage: upload-snapshot.sh --file <local-snapshot-path> --remote <remote-name>
+
+Uploads a local dashboard snapshot HTML file to a configured rclone remote
+via `rclone copyto`, at the templated destination path:
+
+  JengaAI/<repo-directory-name>/<datetime>-board-snapshot.html
+
+  --file <path>     Path to the local snapshot HTML file to upload. Must
+                     exist and be non-empty.
+  --remote <name>   Name of an already-configured rclone remote (no
+                     trailing colon). If not configured, this script tells
+                     you to run j.cloud-connect instead of attempting the
+                     upload.
+
+Upload only — never runs `rclone link` or any other sharing/link-creating
+command.
+EOF
+}
+
+die() {
+  echo "Error: $*" >&2
+  exit 1
+}
+
+# -----------------------------------------------------------------------------
+# Argument parsing.
+# -----------------------------------------------------------------------------
+
+LOCAL_FILE=""
+REMOTE_NAME=""
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    --file)
+      [ "$#" -ge 2 ] || die "--file requires a value"
+      LOCAL_FILE="$2"
+      shift 2
+      ;;
+    --remote)
+      [ "$#" -ge 2 ] || die "--remote requires a value"
+      REMOTE_NAME="$2"
+      shift 2
+      ;;
+    *)
+      usage >&2
+      die "unknown argument: $1"
+      ;;
+  esac
+done
+
+[ -n "$LOCAL_FILE" ] || { usage >&2; die "--file is required"; }
+[ -n "$REMOTE_NAME" ] || { usage >&2; die "--remote is required"; }
+
+# -----------------------------------------------------------------------------
+# Preflight — local file, rclone availability, git repository.
+# -----------------------------------------------------------------------------
+
+[ -f "$LOCAL_FILE" ] || die "local snapshot file not found: $LOCAL_FILE"
+[ -s "$LOCAL_FILE" ] || die "local snapshot file is empty: $LOCAL_FILE"
+
+command -v rclone >/dev/null 2>&1 || die "rclone is not on PATH. Install it first (see skills/j-cloud-connect/scripts/install-rclone.sh) and re-run."
+
+REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || die "not inside a git repository — cannot derive <repo-directory-name> for the destination path. Run this script from within the project's repository."
+REPO_DIR_NAME="$(basename "$REPO_ROOT")"
+
+# -----------------------------------------------------------------------------
+# Step 1 — Verify the target remote is actually configured BEFORE attempting
+# any upload. Never let a raw rclone error surface for "remote not
+# configured" — point the user at j.cloud-connect instead.
+# -----------------------------------------------------------------------------
+
+REMOTES_OUTPUT="$(rclone listremotes 2>&1)" || die "'rclone listremotes' failed: $REMOTES_OUTPUT"
+
+if ! printf '%s\n' "$REMOTES_OUTPUT" | grep -Fxq "${REMOTE_NAME}:"; then
+  die "remote '$REMOTE_NAME' is not configured in rclone. Run j.cloud-connect first to set it up, then re-run this upload."
+fi
+
+# -----------------------------------------------------------------------------
+# Step 2 — Build the templated destination path.
+# -----------------------------------------------------------------------------
+
+DATETIME="$(date -u +%Y%m%dT%H%M%SZ)"
+DEST_RELATIVE_PATH="JengaAI/${REPO_DIR_NAME}/${DATETIME}-board-snapshot.html"
+DEST="${REMOTE_NAME}:${DEST_RELATIVE_PATH}"
+
+# -----------------------------------------------------------------------------
+# Step 3 — Upload. stdio inherited (no capture/reformatting), matching this
+# repo's j-cloud-connect script conventions. Upload only: this script never
+# calls `rclone link` or any other sharing/link-creating command.
+# -----------------------------------------------------------------------------
+
+echo "Uploading '$LOCAL_FILE' to '$DEST'..."
+
+COPY_EXIT=0
+rclone copyto "$LOCAL_FILE" "$DEST" || COPY_EXIT=$?
+if [ "$COPY_EXIT" -ne 0 ]; then
+  die "'rclone copyto $LOCAL_FILE $DEST' exited with status $COPY_EXIT. Upload did not succeed — see rclone's output above for the reason."
+fi
+
+echo "Upload succeeded."
+echo "$DEST"

package/skills/j-init/SKILL.md

@@ -104,10 +104,41 @@ run can never silently relocate directories or edit `.gitignore`.
 > `skills/distribute/CONFIG_SCHEMA.md` for the root-cause note and the tracked
 > follow-up to reintroduce it once fixed.
 
-Carry the chosen value into step 3. Do not apply it yourself — the script owns all
+Carry the chosen value into step 4. Do not apply it yourself — the script owns all
 of the mechanical work.
 
-### 3. Run the scaffold script
+### 3. Ask whether the distributed scaffold should be committed
+
+This is a **distinct** question from step 2 — `project_files_visibility` (step 2)
+covers only the `project/` working tree (the scrum board, `todo.md`, `queue/`,
+`rapports/`, `logs/`). It has no effect on `.claude/`/`.agents/`, the distributed
+framework scaffold (skill and agent definitions), which is a separate tree with a
+separate lifecycle — it gets overwritten wholesale by every `/distribute` run or npm
+upgrade, unlike `project/`. Kept as its own flag (`scaffold_visibility`) rather than
+folded into `project_files_visibility`'s enum; see
+`skills/distribute/CONFIG_SCHEMA.md`'s "Scaffold visibility" section for the full
+rationale.
+
+Ask the user this question, verbatim, before running any script:
+
+    Should the distributed .claude/.agents Jenga AI framework scaffold (skills, agent
+    definitions — implementation detail, not your own code) be committed into this
+    project's git history?
+    1. Yes, commit it — keep it tracked and visible, exactly like today
+    2. No, keep it on disk but add it to .gitignore so it's never committed
+    3. Not sure — explain the trade-offs and ask me again
+
+If the user picks option 3, explain the trade-offs and re-ask. Do not proceed until
+the answer maps to one of `visible` (option 1) or `ignored` (option 2).
+
+If the run is non-interactive (no user available to answer), use the default:
+**`visible`**. It is the only choice that changes nothing on disk, so an unattended
+run reproduces exactly today's behavior — the scaffold is still committed by default.
+
+Carry the chosen value into step 4 as well. Do not apply it yourself — the script
+owns all of the mechanical work.
+
+### 4. Run the scaffold script
 
 `init.sh` is not guaranteed to live at a single fixed path: in a project that
 installed Jenga via npm, it was mirrored to `.claude/skills/j-init/scripts/`
@@ -117,7 +148,7 @@ source checkout, where it lives at the bare `skills/j-init/scripts/` path
 instead. This step runs before `CLAUDE.md`/`AGENTS.md` exist, so it cannot
 rely on either file's routing instructions to resolve the path — it must
 locate its own script directly. Execute the init script from the project
-root, passing the choice from step 2:
+root, passing the choices from steps 2 and 3:
 
 ```bash
 INIT_SCRIPT=""
@@ -128,11 +159,14 @@ if [[ -z "$INIT_SCRIPT" ]]; then
   echo "Error: could not locate init.sh under .claude/skills/, .agents/skills/, or skills/" >&2
   exit 1
 fi
-chmod +x "$INIT_SCRIPT" && "$INIT_SCRIPT" --visibility <visible|ignored>
+chmod +x "$INIT_SCRIPT" && "$INIT_SCRIPT" --visibility <visible|ignored> --scaffold-visibility <visible|ignored>
 ```
 
 Omitting `--visibility` falls back to the `JENGA_PROJECT_FILES_VISIBILITY`
-environment variable, then to `visible`.
+environment variable, then to `visible`. Omitting `--scaffold-visibility` falls
+back to the `JENGA_SCAFFOLD_VISIBILITY` environment variable, then to `visible`
+— the same default-preserving fallback chain, applied independently to the
+distributed-scaffold question from step 3.
 
 This script handles all scaffolding in one step:
 1. Initializes the git repository
@@ -148,22 +182,27 @@ This script handles all scaffolding in one step:
 11. Creates `docs/STRATEGY.md` — a strategic brief stub intended for investors, partners, and the product team
 12. Creates `CHANGELOG.md` from the shared template — a running log of notable changes, seeded with an `[Unreleased]` section
 13. Applies the chosen visibility mode via `scripts/apply-project-visibility.sh`, which records it as `project_files_visibility` in `jenga.config.json` and performs any `.gitignore` change
-14. Stages and commits all files with the message `init: scaffold project structure and workflow config`
+14. Applies the chosen scaffold visibility mode via `scripts/apply-scaffold-visibility.sh`, which records it as `scaffold_visibility` in `jenga.config.json` and, when `ignored`, adds `.claude/` and `.agents/` to `.gitignore`
+15. Stages and commits all files with the message `init: scaffold project structure and workflow config`
 
-The visibility mode is validated before any scaffolding happens, so an invalid
-value fails fast and leaves nothing behind. It is applied before the commit, so
-the `.gitignore` entry is captured in the initial commit.
+Both visibility modes are validated before any scaffolding happens, so an invalid
+value fails fast and leaves nothing behind. Both are applied before the commit, so
+any resulting `.gitignore` entries are captured in the initial commit — this is what
+lets `scaffold_visibility: ignored` keep `.claude/`/`.agents/` out of the commit even
+though they may already exist on disk (from npm postinstall or a prior `/distribute`
+run) by the time `/init` runs `git add -A`.
 
 If the script fails, check that you are in the project root and that git and `jq`
 are available.
 
-See `skills/distribute/CONFIG_SCHEMA.md` for the full `project_files_visibility`
-field reference.
+See `skills/distribute/CONFIG_SCHEMA.md` for the full `project_files_visibility` and
+`scaffold_visibility` field reference.
 
-### 4. Prompt next step
+### 5. Prompt next step
 
 Inform the user that setup is complete, and state which visibility mode was applied
-and where the working files now live. Mention that `docs/STRATEGY.md` was created as
+for both `project_files_visibility` and `scaffold_visibility`, and where the working
+files and scaffold now live. Mention that `docs/STRATEGY.md` was created as
 a strategic brief stub for investors, partners, and the product team — they can fill
 it in now or return to it later. Suggest running `/pi-plan` to define project goals
 and epics.

package/skills/j-init/assets/.gitignore_template

@@ -11,5 +11,4 @@ Desktop.ini
 # Dependency directories
 node_modules/
 vendor/
-.venv/
-EOF
+.venv/

package/skills/j-init/scripts/apply-scaffold-visibility.sh

@@ -0,0 +1,192 @@
+#!/usr/bin/env bash
+#
+# apply-scaffold-visibility.sh — apply the `scaffold_visibility` mode to a project.
+#
+# This is a DISTINCT flag from `project_files_visibility` (see
+# apply-project-visibility.sh). `project_files_visibility` covers the
+# project/ working tree (scrum board, todo.md, queue/, rapports/, logs/) —
+# E31_S05's own Background section scopes it to that tree only. This script
+# instead covers the *distributed framework scaffold* — `.claude/` and
+# `.agents/` — which is a different tree with a different lifecycle (it is
+# overwritten wholesale by every `/distribute` run or npm upgrade; project/
+# is not). Filed as new, adjacent scope under E31_S07 rather than folded
+# silently into project_files_visibility's existing enum. See
+# skills/distribute/CONFIG_SCHEMA.md's "Scaffold visibility" section for the
+# full rationale.
+#
+# This is skills/j-init/'s own copy of skills/init/scripts/apply-scaffold-visibility.sh
+# (E31_S07_T03) — skills/j-init/ is a separate, hand-maintained directory, not
+# auto-synced with skills/init/ (scripts/generate-j-alias.sh explicitly excludes
+# this pair), and is the copy that actually ships to public-GitHub-mirror and
+# npm-package consumers. Keep this file's logic in lockstep with skills/init/'s
+# copy — any behavioral change made there should be mirrored here.
+#
+# Usage:
+#   apply-scaffold-visibility.sh <mode> [project_root]
+#   apply-scaffold-visibility.sh --check-only <mode>
+#
+# Modes:
+#   visible   Scaffold directories stay where they are. No-op on disk beyond
+#             the config write. This is the default — matches the behavior
+#             of every /init run before this flag existed.
+#   ignored   .claude/ and .agents/ are added to the project's .gitignore —
+#             present on disk (whenever npm postinstall or /distribute
+#             places them, whether that happens before or after this runs),
+#             never committed. Entries are written unconditionally, the same
+#             way apply-project-visibility.sh gitignores project/ whether or
+#             not it exists yet, so a scaffold created by a later
+#             /distribute run is covered too, not just one already on disk.
+#
+# Exit codes:
+#   0  Success
+#   1  Bad usage or missing prerequisite
+#   2  Invalid mode (outside the two-value enum)
+#   3  Filesystem apply failure
+#   4  jenga.config.json write failure
+
+# Do NOT use set -e globally — each step handles its own errors.
+set -uo pipefail
+
+info() { echo "[scaffold-visibility] $*"; }
+warn() { echo "[scaffold-visibility] WARNING: $*"; }
+err()  { echo "[scaffold-visibility] ERROR: $*" >&2; }
+
+usage() {
+  echo "Usage: $(basename "$0") <visible|ignored> [project_root]" >&2
+  echo "       $(basename "$0") --check-only <visible|ignored>" >&2
+  exit 1
+}
+
+# The distributed framework scaffold — mirrored copies of skills/agents for
+# Claude Code and Copilot/other agents. Distinct from JENGA_WORKING_PATHS in
+# apply-project-visibility.sh, which covers project/ only.
+JENGA_SCAFFOLD_PATHS=(".claude" ".agents")
+
+VALID_MODES="visible ignored"
+
+validate_mode() {
+  local mode="$1"
+  for valid in $VALID_MODES; do
+    [ "$mode" = "$valid" ] && return 0
+  done
+  err "Invalid scaffold_visibility value: '${mode}'"
+  err "Allowed values are: ${VALID_MODES// /, }"
+  exit 2
+}
+
+# ---------------------------------------------------------------------------
+# Argument parsing
+# ---------------------------------------------------------------------------
+
+CHECK_ONLY=0
+if [ "${1:-}" = "--check-only" ]; then
+  CHECK_ONLY=1
+  shift
+fi
+
+MODE="${1:-}"
+[ -n "$MODE" ] || usage
+
+validate_mode "$MODE"
+
+if [ "$CHECK_ONLY" -eq 1 ]; then
+  info "Mode '$MODE' is valid."
+  exit 0
+fi
+
+PROJECT_ROOT="${2:-$PWD}"
+if [ ! -d "$PROJECT_ROOT" ]; then
+  err "Project root does not exist: $PROJECT_ROOT"
+  exit 1
+fi
+cd "$PROJECT_ROOT" || { err "Cannot enter project root: $PROJECT_ROOT"; exit 1; }
+
+if ! command -v jq >/dev/null 2>&1; then
+  err "jq is required to write jenga.config.json but was not found on PATH."
+  exit 1
+fi
+
+# ---------------------------------------------------------------------------
+# ignored — append to .gitignore, without ever duplicating an entry
+# ---------------------------------------------------------------------------
+
+gitignore_append() {
+  local entry="$1"
+  local gitignore=".gitignore"
+
+  if [ -f "$gitignore" ] && grep -qxF -- "$entry" "$gitignore"; then
+    info "'$entry' already present in .gitignore — skipping."
+    return 0
+  fi
+
+  # Don't glue our entry onto a final line that lacks a newline.
+  if [ -s "$gitignore" ] && [ -n "$(tail -c 1 "$gitignore")" ]; then
+    printf '\n' >> "$gitignore"
+  fi
+
+  if ! printf '%s\n' "$entry" >> "$gitignore"; then
+    err "Failed to append '$entry' to .gitignore"
+    exit 3
+  fi
+  info "Added '$entry' to .gitignore"
+}
+
+# ---------------------------------------------------------------------------
+# jenga.config.json — merge the field in, written atomically (temp + mv)
+# ---------------------------------------------------------------------------
+
+write_scaffold_config() {
+  local mode="$1"
+  local config="jenga.config.json"
+  local tmp="${config}.tmp"
+  local existing='{}'
+
+  # /init normally runs before any /distribute, so the file usually does not
+  # exist yet. Merge rather than overwrite so other fields survive.
+  if [ -f "$config" ]; then
+    if ! jq empty "$config" 2>/dev/null; then
+      err "$config exists but contains malformed JSON — refusing to overwrite it."
+      exit 4
+    fi
+    existing="$(cat "$config")"
+  fi
+
+  local content
+  content="$(jq --arg v "$mode" '.scaffold_visibility = $v' <<< "$existing")"
+  if [ -z "$content" ]; then
+    err "Failed to construct $config content."
+    exit 4
+  fi
+
+  if ! printf '%s\n' "$content" > "$tmp"; then
+    err "Failed to write temporary config file: $tmp"
+    exit 4
+  fi
+
+  if ! mv "$tmp" "$config"; then
+    err "Failed to atomically move $tmp to $config"
+    rm -f "$tmp"
+    exit 4
+  fi
+
+  info "Wrote scaffold_visibility = \"$mode\" to $config"
+}
+
+# ---------------------------------------------------------------------------
+# Apply
+# ---------------------------------------------------------------------------
+
+case "$MODE" in
+  visible)
+    info "Mode 'visible' — scaffold directories stay in place; nothing to change on disk."
+    ;;
+  ignored)
+    for path in "${JENGA_SCAFFOLD_PATHS[@]}"; do
+      gitignore_append "${path}/"
+    done
+    ;;
+esac
+
+write_scaffold_config "$MODE"
+
+info "Applied scaffold_visibility '$MODE' to $PROJECT_ROOT"

package/skills/j-init/scripts/init.sh

@@ -4,6 +4,7 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 ASSETS_DIR="$SCRIPT_DIR/../assets"
 VISIBILITY_SCRIPT="$SCRIPT_DIR/apply-project-visibility.sh"
+SCAFFOLD_VISIBILITY_SCRIPT="$SCRIPT_DIR/apply-scaffold-visibility.sh"
 
 # ─── Resolve the package root that owns templates/ and lib/ ──────────────────
 # postinstall.js mirrors only skills/ and agents/ into .claude/ and .agents/ —
@@ -22,23 +23,33 @@ else
   exit 1
 fi
 
-# ─── 0. Resolve project_files_visibility ─────────────────────────────────────
+# ─── 0. Resolve project_files_visibility and scaffold_visibility ─────────────
 # Defaults to `visible` — the only value that touches nothing on disk — so an
 # unattended run can never silently relocate directories or edit .gitignore.
+# project_files_visibility covers the project/ working tree (board, todo.md,
+# queue/, rapports/, logs/). scaffold_visibility is a distinct, independent
+# flag (E31_S07_T01, ported here in E31_S07_T03) covering the distributed
+# .claude/.agents framework scaffold — kept separate per
+# skills/distribute/CONFIG_SCHEMA.md's "Scaffold visibility" section, rather
+# than folded into project_files_visibility's existing enum.
 VISIBILITY="${JENGA_PROJECT_FILES_VISIBILITY:-visible}"
+SCAFFOLD_VISIBILITY="${JENGA_SCAFFOLD_VISIBILITY:-visible}"
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
     --visibility)   VISIBILITY="${2:-}"; shift 2 ;;
     --visibility=*) VISIBILITY="${1#*=}"; shift ;;
+    --scaffold-visibility)   SCAFFOLD_VISIBILITY="${2:-}"; shift 2 ;;
+    --scaffold-visibility=*) SCAFFOLD_VISIBILITY="${1#*=}"; shift ;;
     *) echo "Unknown argument: $1" >&2
-       echo "Usage: $(basename "$0") [--visibility <visible|ignored>]" >&2
+       echo "Usage: $(basename "$0") [--visibility <visible|ignored>] [--scaffold-visibility <visible|ignored>]" >&2
        exit 1 ;;
   esac
 done
 
 # Validate before scaffolding so a typo cannot leave a half-initialised project.
 bash "$VISIBILITY_SCRIPT" --check-only "$VISIBILITY"
+bash "$SCAFFOLD_VISIBILITY_SCRIPT" --check-only "$SCAFFOLD_VISIBILITY"
 
 # ─── 1. Initialize git repository ────────────────────────────────────────────
 echo "→ Initializing git repository..."
@@ -101,11 +112,14 @@ cp "$ASSETS_DIR/strategy_stub_template.md" docs/STRATEGY.md
 echo "→ Creating CHANGELOG.md from template..."
 cp "$PKG_ROOT/templates/CHANGELOG_TEMPLATE.md" CHANGELOG.md
 
-# ─── 11. Apply project_files_visibility ──────────────────────────────────────
-# Runs before the commit so the .gitignore entry (ignored) is captured in the
-# initial commit.
+# ─── 11. Apply project_files_visibility and scaffold_visibility ─────────────
+# Both run before the commit so any resulting .gitignore entries (ignored)
+# are captured in the initial commit rather than left for the user to notice
+# after the fact.
 echo "→ Applying project files visibility ($VISIBILITY)..."
 bash "$VISIBILITY_SCRIPT" "$VISIBILITY" "$PWD"
+echo "→ Applying scaffold visibility ($SCAFFOLD_VISIBILITY)..."
+bash "$SCAFFOLD_VISIBILITY_SCRIPT" "$SCAFFOLD_VISIBILITY" "$PWD"
 
 # ─── 12. Generate CLAUDE.md / AGENTS.md ──────────────────────────────────────
 # Unconditional — never gated on agentTarget (E41_S04). Applies the J-

package/skills/j-playbook/SKILL.md

@@ -32,6 +32,18 @@ this skill is id resolution (step 1 below).
 
 ## Instructions
 
+0. **Bare invocation — no id given.** If this skill was invoked with no argument at all, do not
+   proceed to step 1. Instead:
+   a. Invoke `skills/jenga/scripts/load-playbooks.sh` with no arguments (its existing full-catalog
+      mode — the same call step 1's `"not_found"` branch already uses for its "did you mean"
+      nudge; no new script is introduced for this).
+   b. Render the returned JSON array as a Markdown table with columns `Id`, `Name`, `Source`, and
+      `Steps`. For the `Source` column, render `Built-in` for a `source` field of `"builtin"` and
+      `Project` for `"project"`. For the `Steps` column, render each entry in that playbook's
+      `steps` array joined by `->`: a bare string step renders as itself; a StepObject step
+      renders its `skill` or `playbook` field value (whichever is present).
+   c. Halt this invocation after rendering the table — do not proceed to step 1.
+
 1. **Resolve the id** — invoke `skills/jenga/scripts/load-playbooks.sh lookup "<id>"`
    (`E53_S06_T02`), where `<id>` is this skill's argument. Branch on the returned `status` field: