@jenga-ai/agent 3.1.0 → 3.2.0

package/scripts/build-pages-site.sh

@@ -0,0 +1,268 @@
+#!/usr/bin/env bash
+# scripts/build-pages-site.sh
+#
+# Deterministically (re)generates the wiki-derived pages of the GitHub Pages
+# documentation site (docs/*.md) from the existing wiki mirror under
+# project/.wiki/. This is the sync mechanism behind E41_S13_T01's
+# source-of-truth decision ("restructure from the wiki, keep both in sync"):
+# project/.wiki/ stays the canonical, doc-sync-maintained content; this
+# script is the deterministic transform from that content into the
+# multi-page, navigable Pages site.
+#
+# WHEN TO RE-RUN: after `j.doc-sync` (or any manual edit) updates
+# project/.wiki/documentation.md, project/.wiki/intro-guide.md, or
+# project/.wiki/concepts/*.md, re-run this script to refresh the Pages site
+# so it doesn't silently drift from the wiki the way README.md and the wiki
+# itself have drifted from each other before (see skills/doc-sync/SKILL.md
+# for the doc-sync side of this convention).
+#
+# WHAT THIS SCRIPT DOES NOT TOUCH:
+#   - docs/_config.yml, docs/index.md — hand-authored site structure/config,
+#     not derived from wiki content. Edit these directly if the page set or
+#     nav changes.
+#   - docs/README.md — maintainer-facing decision record, not a rendered
+#     Jekyll page and not wiki-derived content.
+#
+# WHAT THIS SCRIPT REGENERATES (always overwritten, never hand-edit these):
+#   - docs/getting-started.md   <- project/.wiki/intro-guide.md
+#   - docs/concepts.md          <- project/.wiki/concepts/*.md (concatenated)
+#   - docs/skills.md            <- project/.wiki/documentation.md "## Skills"
+#   - docs/agents.md            <- project/.wiki/documentation.md "## Agents"
+#   - docs/hooks.md             <- project/.wiki/documentation.md "## Hooks"
+#   - docs/mcp-tools.md         <- project/.wiki/documentation.md "## MCP Tools"
+#   - docs/reference.md         <- project/.wiki/documentation.md
+#                                   "## Directory Structure" +
+#                                   "## Agent Communication Contract"
+#                                   (plus a short hand-authored index blurb
+#                                   linking to skills/agents/hooks/mcp-tools)
+#
+# KNOWN LIMITATION: this is a structural transform, not a fact-checker. It
+# ports project/.wiki/documentation.md's content as-is, including whatever
+# is currently stale in that file (e.g. it documents ~30 skills under the
+# old bare `/<name>` invocation form and does not yet list every skill in
+# skills/, including the `j-<name>` twins — a pre-existing wiki staleness
+# gap, not something introduced by this script). Fixing the wiki's own
+# staleness is doc-sync's job, not this script's — this script only keeps
+# the Pages site faithful to whatever the wiki currently says.
+#
+# HEADING-STABILITY ASSUMPTION: section extraction below is keyed to exact
+# top-level ("## ") heading text in documentation.md (Agents, Skills, MCP
+# Tools, Hooks, Directory Structure, Agent Communication Contract). If any
+# of those headings are renamed, update the `case` statement in
+# extract_sections() to match.
+#
+# Usage: scripts/build-pages-site.sh
+# Safe to re-run any number of times — every run fully overwrites its
+# output files from the current wiki content (no partial/incremental state).
+
+set -euo pipefail
+
+# shellcheck source=lib/resolve-project-dir.sh disable=SC1091
+source "$(git rev-parse --show-toplevel)/lib/resolve-project-dir.sh"
+
+REPO_ROOT="$JENGA_PROJECT_DIR"
+WIKI_DIR="$REPO_ROOT/project/.wiki"
+DOCS_DIR="$REPO_ROOT/docs"
+DOC_MD="$WIKI_DIR/documentation.md"
+INTRO_MD="$WIKI_DIR/intro-guide.md"
+CONCEPTS_DIR="$WIKI_DIR/concepts"
+
+for f in "$DOC_MD" "$INTRO_MD"; do
+  if [ ! -f "$f" ]; then
+    echo "build-pages-site.sh: required source file not found: $f" >&2
+    exit 1
+  fi
+done
+if [ ! -d "$CONCEPTS_DIR" ]; then
+  echo "build-pages-site.sh: required source directory not found: $CONCEPTS_DIR" >&2
+  exit 1
+fi
+
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+
+# --- 1. Split documentation.md into per-section scratch files -------------
+# A line can only belong to one target section at a time; the generic
+# "any other ## heading" rule resets `section` to "" so unrelated top-level
+# sections (e.g. "## Table of Contents") are dropped rather than bleeding
+# into whichever named section preceded them.
+awk -v work="$WORK" '
+  /^## Agents$/                             { section = "agents"; next }
+  /^## Skills$/                             { section = "skills"; next }
+  /^## MCP Tools$/                          { section = "mcp-tools"; next }
+  /^## Hooks$/                              { section = "hooks"; next }
+  /^## Directory Structure$/                { section = "directory-structure"; next }
+  /^## Agent Communication Contract$/       { section = "contract"; next }
+  /^## /                                    { section = "" }
+  {
+    if (section != "") {
+      print >> (work "/section-" section ".md")
+    }
+  }
+' "$DOC_MD"
+
+for s in agents skills mcp-tools hooks directory-structure contract; do
+  [ -f "$WORK/section-$s.md" ] || touch "$WORK/section-$s.md"
+done
+
+write_page() {
+  # write_page <output-path> <title> <permalink> <body-file>
+  local out="$1" title="$2" permalink="$3" body="$4"
+  {
+    printf -- '---\n'
+    printf 'layout: page\n'
+    printf 'title: %s\n' "$title"
+    printf 'permalink: %s\n' "$permalink"
+    printf -- '---\n\n'
+    cat "$body"
+  } > "$out"
+}
+
+# --- 2. docs/agents.md, docs/hooks.md, docs/mcp-tools.md -------------------
+# Straight ports — no internal markdown links were found in these sections
+# of documentation.md, so no link rewriting is needed beyond the front
+# matter wrapper.
+write_page "$DOCS_DIR/agents.md" "Agents" "/agents.html" "$WORK/section-agents.md"
+write_page "$DOCS_DIR/hooks.md" "Hooks" "/hooks.html" "$WORK/section-hooks.md"
+write_page "$DOCS_DIR/mcp-tools.md" "MCP Tools" "/mcp-tools.html" "$WORK/section-mcp-tools.md"
+
+# --- 3. docs/skills.md ------------------------------------------------------
+# Single reference page (matches the story's own suggested top-level
+# category list: Getting Started / Concepts / Skills reference / Agents /
+# Hooks / MCP Tools — "Skills reference" is one page, not one page per
+# skill). Category (### ) and per-skill (#### ) structure is preserved
+# as-is from the source.
+write_page "$DOCS_DIR/skills.md" "Skills Reference" "/skills.html" "$WORK/section-skills.md"
+
+# --- 4. docs/reference.md ---------------------------------------------------
+# Combines the two remaining documentation.md sections (Directory Structure,
+# Agent Communication Contract) behind a short hand-authored index blurb
+# that links out to the pages built above — this replaces documentation.md's
+# original role as the single "full reference" entry point, now that its
+# content is split across multiple pages.
+{
+  cat <<'EOF'
+## Full Reference Index
+
+This page is the entry point into the full reference material, split across
+several pages so nothing requires scrolling through one giant file:
+
+- **[Skills Reference](./skills.md)** — every skill, grouped by Setup &
+  Planning, Execution, Status & Review, and Committing & Maintenance.
+- **[Agents](./agents.md)** — Scrum Master, Developer, Tester: roles,
+  ownership, and responsibilities.
+- **[Hooks](./hooks.md)** — session lifecycle hooks and what they run.
+- **[MCP Tools](./mcp-tools.md)** — Model Context Protocol tools available
+  in a Claude Code session.
+
+The rest of this page covers the repo's directory structure and the
+inter-agent communication contract (the typed "sender object" every agent
+call carries).
+
+---
+
+EOF
+  cat "$WORK/section-directory-structure.md"
+  printf '\n---\n\n'
+  cat "$WORK/section-contract.md"
+} > "$WORK/reference-body.md"
+write_page "$DOCS_DIR/reference.md" "Reference" "/reference.html" "$WORK/reference-body.md"
+
+# --- 5. docs/getting-started.md ---------------------------------------------
+# Port of intro-guide.md verbatim (drop the leading H1 — front matter
+# supplies the page title instead), with its two links into the
+# now-restructured reference/concepts pages rewritten.
+tail -n +2 "$INTRO_MD" > "$WORK/intro-body.md"
+# NOTE on delimiter choice: sed's `s<delim>pattern<delim>replacement<delim>`
+# breaks if the replacement text itself contains the delimiter character.
+# Several replacements below contain a literal "#" (anchor fragments), so
+# "#" cannot be used as the delimiter here — "|" is used instead, since
+# none of these paths/anchors contain a literal "|".
+sed -i.bak \
+  -e 's|\[documentation\.md\](\./documentation\.md)|[reference.md](./reference.md)|g' \
+  -e 's|(\./concepts/role-separation\.md)|(./concepts.md#role-separation)|g' \
+  -e 's|(\./concepts/board-hierarchy\.md)|(./concepts.md#board-hierarchy)|g' \
+  -e 's|(\./concepts/session-continuity\.md)|(./concepts.md#session-continuity)|g' \
+  -e 's|(\./concepts/first-feature\.md)|(./concepts.md#your-first-feature)|g' \
+  -e 's|(\./concepts/multi-session-work\.md)|(./concepts.md#working-across-sessions)|g' \
+  -e 's|(\./concepts/mid-flow-capture\.md)|(./concepts.md#capturing-mid-flow-ideas)|g' \
+  -e 's|(\./concepts/parallel-tasks\.md)|(./concepts.md#parallel-tasks)|g' \
+  "$WORK/intro-body.md"
+rm -f "$WORK/intro-body.md.bak"
+write_page "$DOCS_DIR/getting-started.md" "Getting Started" "/getting-started.html" "$WORK/intro-body.md"
+
+# --- 6. docs/concepts.md -----------------------------------------------------
+# Concatenates all 7 project/.wiki/concepts/*.md files into one page:
+#   - each file's H1 becomes an H2 section heading (slug listed below must
+#     stay in sync with each file's actual title text — GitHub Pages/kramdown
+#     slugifies headings to lowercase-hyphenated automatically)
+#   - all other headings are demoted one level (## -> ###, ### -> ####)
+#   - sibling/parent links are rewritten to point within the merged page
+#     and at the sibling getting-started.md / reference.md pages
+#
+{
+  cat <<'EOF'
+## Concepts
+
+The ideas behind Jenga AI's structure, and the how-tos for using it day to
+day. Jump to any section:
+
+- [Role Separation](#role-separation)
+- [Board Hierarchy](#board-hierarchy)
+- [Session Continuity](#session-continuity)
+- [Your First Feature](#your-first-feature)
+- [Working Across Sessions](#working-across-sessions)
+- [Capturing Mid-Flow Ideas](#capturing-mid-flow-ideas)
+- [Parallel Tasks](#parallel-tasks)
+
+---
+
+EOF
+} > "$WORK/concepts-body.md"
+
+append_concept() {
+  # append_concept <filename-stem> <section-title>
+  local stem="$1"
+  local title="$2"
+  local src="$CONCEPTS_DIR/$stem.md"
+  {
+    printf '## %s\n\n' "$title"
+    # NOTE on delimiter choice: same reasoning as the getting-started block
+    # above — replacements here contain a literal "#" anchor character, so
+    # "|" is used as the sed delimiter instead of "#".
+    #
+    # NOTE on heading demotion: a naive two-pass "## -> ###" then
+    # "### -> ####" sed would double-demote lines that were originally
+    # "## " (they'd match the first rule, becoming "### ", and then ALSO
+    # match the second rule on the same pass, becoming "#### " — wrong).
+    # The single extended-regex rule below captures the existing run of
+    # 2-3 "#" characters and prepends exactly one more, so each line is
+    # demoted exactly once regardless of its original level.
+    tail -n +2 "$src" \
+      | sed \
+        -e 's|\[documentation\.md\](\.\./documentation\.md)|[reference.md](./reference.md)|g' \
+        -e 's|(\.\./intro-guide\.md)|(./getting-started.md)|g' \
+        -e 's|(\.\./documentation\.md)|(./reference.md)|g' \
+        -e 's|(\./role-separation\.md)|(#role-separation)|g' \
+        -e 's|(\./board-hierarchy\.md)|(#board-hierarchy)|g' \
+        -e 's|(\./session-continuity\.md)|(#session-continuity)|g' \
+        -e 's|(\./first-feature\.md)|(#your-first-feature)|g' \
+        -e 's|(\./multi-session-work\.md)|(#working-across-sessions)|g' \
+        -e 's|(\./mid-flow-capture\.md)|(#capturing-mid-flow-ideas)|g' \
+        -e 's|(\./parallel-tasks\.md)|(#parallel-tasks)|g' \
+      | sed -E 's/^(#{2,3}) /#\1 /'
+    printf '\n---\n\n'
+  } >> "$WORK/concepts-body.md"
+}
+
+append_concept "role-separation" "Role Separation"
+append_concept "board-hierarchy" "Board Hierarchy"
+append_concept "session-continuity" "Session Continuity"
+append_concept "first-feature" "Your First Feature"
+append_concept "multi-session-work" "Working Across Sessions"
+append_concept "mid-flow-capture" "Capturing Mid-Flow Ideas"
+append_concept "parallel-tasks" "Parallel Tasks"
+
+write_page "$DOCS_DIR/concepts.md" "Concepts" "/concepts.html" "$WORK/concepts-body.md"
+
+echo "build-pages-site.sh: regenerated docs/{getting-started,concepts,skills,agents,hooks,mcp-tools,reference}.md from project/.wiki/*"

package/scripts/check-public-playbook-steps.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+#
+# scripts/check-public-playbook-steps.sh — every public playbook's steps must ship publicly
+#
+# E50_S20_T01. Guards the invariant that a playbook shipped to the public mirror can actually
+# run there: for each playbook JSON that `.publicignore` does NOT block, every step must resolve
+# to a skill directory that `.publicignore` also does not block.
+#
+# Why this exists: `skills/jenga/scripts/load-playbooks.sh` requires every step's
+# `skills/<dir>/SKILL.md` to exist, and silently SKIPS the whole playbook (stderr warning only)
+# when one is missing. In the private repo every skill is present, so a playbook referencing a
+# private-only skill looks perfectly healthy — the breakage appears only in the public mirror,
+# where it surfaced as a stage-deploy gate failure rather than as a test failure (E50_S13).
+# This check reproduces that condition statically, on the private side, before anything ships.
+#
+# Blocklist semantics are NOT re-derived here. Classification is delegated to
+# scripts/check-publicignore-match.sh, which itself reuses /mirror-public's own
+# `rsync --exclude-from=.publicignore` matching — a second, hand-rolled answer to "is this path
+# blocked" is exactly the drift this repo has been bitten by before.
+#
+# Composed steps: a StepObject of the form {"playbook": "<id>"} composes another playbook. Its
+# own steps are checked when that playbook is itself public; a public playbook composing a
+# BLOCKED playbook is a violation in its own right, since the composed id will not resolve in
+# the mirror (see tests/load-playbooks-composition.bats's nonexistent-playbook-id behaviour).
+#
+# Usage:
+#   scripts/check-public-playbook-steps.sh [<repo-root>]
+#
+# Exit codes:
+#   0  every public playbook's every step (and composed playbook) is public
+#   1  at least one violation — each is named on stdout
+#   2  usage / environment error (bad root, missing helper, unparseable playbook)
+
+set -euo pipefail
+
+REPO_ROOT="${1:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+
+if [ ! -d "$REPO_ROOT" ]; then
+  echo "check-public-playbook-steps.sh: error: not a directory: $REPO_ROOT" >&2
+  exit 2
+fi
+
+PLAYBOOKS_DIR="$REPO_ROOT/skills/jenga/playbooks"
+MATCHER="$REPO_ROOT/scripts/check-publicignore-match.sh"
+
+if [ ! -f "$REPO_ROOT/.publicignore" ]; then
+  echo "check-public-playbook-steps.sh: no .publicignore at $REPO_ROOT — nothing to enforce, skipping"
+  exit 0
+fi
+
+if [ ! -f "$MATCHER" ]; then
+  echo "check-public-playbook-steps.sh: error: missing $MATCHER (the single source of blocklist semantics)" >&2
+  exit 2
+fi
+
+if [ ! -d "$PLAYBOOKS_DIR" ]; then
+  echo "check-public-playbook-steps.sh: no playbooks directory at $PLAYBOOKS_DIR — nothing to check"
+  exit 0
+fi
+
+# classify <path-relative-to-repo-root> -> echoes PUBLIC or BLOCKED
+classify() {
+  bash "$MATCHER" "$1" 2>/dev/null | head -1 | cut -f1
+}
+
+violations=0
+checked=0
+skipped_private=0
+
+for pb in "$PLAYBOOKS_DIR"/*.json; do
+  [ -f "$pb" ] || continue
+  base="$(basename "$pb")"
+  # schema.json describes playbooks, it is not one.
+  [ "$base" = "schema.json" ] && continue
+
+  rel="skills/jenga/playbooks/$base"
+  if [ "$(classify "$rel")" = "BLOCKED" ]; then
+    skipped_private=$((skipped_private + 1))
+    continue
+  fi
+
+  checked=$((checked + 1))
+
+  # Emit one "<kind>\t<value>" line per step. A bare string and {"skill": ...} are both skills;
+  # {"playbook": ...} is a composition.
+  steps="$(python3 -c '
+import json, sys
+with open(sys.argv[1]) as fh:
+    pb = json.load(fh)
+for s in pb.get("steps", []):
+    if isinstance(s, str):
+        print("skill\t" + s)
+    elif isinstance(s, dict):
+        if "skill" in s:
+            print("skill\t" + str(s["skill"]))
+        elif "playbook" in s:
+            print("playbook\t" + str(s["playbook"]))
+' "$pb")" || {
+    echo "check-public-playbook-steps.sh: error: could not parse $rel" >&2
+    exit 2
+  }
+
+  while IFS=$'\t' read -r kind value; do
+    [ -n "${kind:-}" ] || continue
+    case "$kind" in
+      skill)
+        target="skills/$value/SKILL.md"
+        if [ ! -f "$REPO_ROOT/$target" ]; then
+          echo "VIOLATION  $rel -> step '$value': no $target on disk"
+          violations=$((violations + 1))
+        elif [ "$(classify "$target")" = "BLOCKED" ]; then
+          echo "VIOLATION  $rel -> step '$value': $target is blocklisted, so this public playbook cannot load in the mirror"
+          violations=$((violations + 1))
+        fi
+        ;;
+      playbook)
+        target="skills/jenga/playbooks/$value.json"
+        if [ ! -f "$REPO_ROOT/$target" ]; then
+          echo "VIOLATION  $rel -> composes '$value': no $target on disk"
+          violations=$((violations + 1))
+        elif [ "$(classify "$target")" = "BLOCKED" ]; then
+          echo "VIOLATION  $rel -> composes '$value': $target is blocklisted, so the composed id will not resolve in the mirror"
+          violations=$((violations + 1))
+        fi
+        ;;
+    esac
+  done <<< "$steps"
+done
+
+if [ "$violations" -gt 0 ]; then
+  echo "check-public-playbook-steps.sh: $violations violation(s) across $checked public playbook(s) ($skipped_private private playbook(s) not checked)"
+  exit 1
+fi
+
+echo "check-public-playbook-steps.sh: OK — $checked public playbook(s) checked, every step ships publicly ($skipped_private private playbook(s) skipped)"
+exit 0

package/skills/j-close-story/SKILL.md

@@ -129,7 +129,7 @@ For **each task ID** listed in the story's `tasks:` frontmatter array:
    ```bash
    bash skills/j-close-story/scripts/check-privatized.sh <task-id> "project/board/tasks/<task-id>_*.md"
    ```
-   This is a **static** check (per `templates/SCRUM_BOARD_SCHEMA.md`'s "Static
+   This is a **static** check (per `$([ -f templates/SCRUM_BOARD_SCHEMA.md ] && echo templates/SCRUM_BOARD_SCHEMA.md || echo node_modules/@jenga-ai/agent/templates/SCRUM_BOARD_SCHEMA.md)`'s "Static
    vs. Reactive Status Setting" section) — it derives the task's touched-file
    list from its own EST-tagged commit history (same technique as Step 2) and
    tests every file against `.publicignore`, with **no dependency on any

package/skills/j-do/SKILL.md

@@ -58,7 +58,7 @@ Extract the following named values for use throughout this skill:
 These values must be read fresh on each invocation. Never use hardcoded fallbacks.
 
 ### 1. Check for `project/todo.md`
-Run `bash scripts/todo_manager.sh exists`. If it exits non-zero, inform the user there are no queued tasks and exit.
+Run `bash "$([ -f scripts/todo_manager.sh ] && echo scripts/todo_manager.sh || echo node_modules/@jenga-ai/agent/scripts/todo_manager.sh)" exists`. If it exits non-zero, inform the user there are no queued tasks and exit.
 
 ### 1.5. Story-Bundle Execution Mode
 
@@ -284,7 +284,7 @@ No patch file is written on success.
 If `/do` is invoked with a task ID (`E##_S##_T##`) or a plain-text title, skip this section and use the normal task execution path (steps 2–8 below).
 
 ### 2. List tasks and let the user choose
-Run `bash scripts/todo_manager.sh list` to display the queued tasks. Ask the user:
+Run `bash "$([ -f scripts/todo_manager.sh ] && echo scripts/todo_manager.sh || echo node_modules/@jenga-ai/agent/scripts/todo_manager.sh)" list` to display the queued tasks. Ask the user:
 - Execute a specific task (by number or title)
 - Execute the next task from the top of the list
 - Exit
@@ -294,14 +294,14 @@ Run `bash scripts/todo_manager.sh list` to display the queued tasks. Ask the use
 Before resolving a task for execution, inspect the selected entry's ID:
 
 - **Epic (`E##`)** — the entry refers to a whole epic that has not yet been broken into stories.
-  Use the scrum-master agent to read the epic's board file (`$(bash scripts/board_resolver.sh)epics/`) and decompose it into stories. For each story produced:
-  1. Write a story file to `$(bash scripts/board_resolver.sh)stories/`.
-  2. Run `bash scripts/todo_manager.sh add '<story title>: <E##_S##>'`
-  After breakdown, Run `bash scripts/todo_manager.sh remove '<epic entry title>'` and go back to step 2 so the new stories are visible.
+  Use the scrum-master agent to read the epic's board file (`$(bash "$([ -f scripts/board_resolver.sh ] && echo scripts/board_resolver.sh || echo node_modules/@jenga-ai/agent/scripts/board_resolver.sh)")epics/`) and decompose it into stories. For each story produced:
+  1. Write a story file to `$(bash "$([ -f scripts/board_resolver.sh ] && echo scripts/board_resolver.sh || echo node_modules/@jenga-ai/agent/scripts/board_resolver.sh)")stories/`.
+  2. Run `bash "$([ -f scripts/todo_manager.sh ] && echo scripts/todo_manager.sh || echo node_modules/@jenga-ai/agent/scripts/todo_manager.sh)" add '<story title>: <E##_S##>'`
+  After breakdown, Run `bash "$([ -f scripts/todo_manager.sh ] && echo scripts/todo_manager.sh || echo node_modules/@jenga-ai/agent/scripts/todo_manager.sh)" remove '<epic entry title>'` and go back to step 2 so the new stories are visible.
 
 - **Story (`E##_S##`) with no tasks** — the entry refers to a story that has not yet been broken into tasks.
-  Check `$(bash scripts/board_resolver.sh)tasks/` for any task files whose front-matter `story_id` matches this story. If none exist, use the scrum-master agent to read the story's board file and decompose it into tasks. For each task produced:
-  1. Write a task file to `$(bash scripts/board_resolver.sh)tasks/`.
+  Check `$(bash "$([ -f scripts/board_resolver.sh ] && echo scripts/board_resolver.sh || echo node_modules/@jenga-ai/agent/scripts/board_resolver.sh)")tasks/` for any task files whose front-matter `story_id` matches this story. If none exist, use the scrum-master agent to read the story's board file and decompose it into tasks. For each task produced:
+  1. Write a task file to `$(bash "$([ -f scripts/board_resolver.sh ] && echo scripts/board_resolver.sh || echo node_modules/@jenga-ai/agent/scripts/board_resolver.sh)")tasks/`.
   After breakdown, keep the story entry in `project/todo.md` (tasks are discovered from it automatically). Go back to step 2.
 
 - **Story (`E##_S##`) with existing tasks**, or **Task (`E##_S##_T##`)** — no breakdown needed; proceed to step 4.
@@ -310,7 +310,7 @@ Before resolving a task for execution, inspect the selected entry's ID:
 Each todo entry uses the format: `<mission title>: <E##_S##_T##>` (or `E##_S##` if no task ID).
 
 Before starting:
-1. Locate and read the matching file from `$(bash scripts/board_resolver.sh)tasks/` (or `$(bash scripts/board_resolver.sh)stories/` if story-level)
+1. Locate and read the matching file from `$(bash "$([ -f scripts/board_resolver.sh ] && echo scripts/board_resolver.sh || echo node_modules/@jenga-ai/agent/scripts/board_resolver.sh)")tasks/` (or `$(bash "$([ -f scripts/board_resolver.sh ] && echo scripts/board_resolver.sh || echo node_modules/@jenga-ai/agent/scripts/board_resolver.sh)")stories/` if story-level)
 2. If the file does not exist, warn the user and skip — do not proceed with a task that has no scrum board definition
 3. Present a brief summary of the task: title, acceptance criteria, parent story, parent epic
 
@@ -343,7 +343,7 @@ After override validation (step 4.1) and before branching on `execution_scope` i
 
 3. **Overwrite `execution_scope` to `inline`** in the task's frontmatter, unconditionally — `--trivial` always forces `inline`, never a softer "lightest safe tier."
 
-4. **Record the override for audit**, reusing the existing `jenga_assigned` / `override_justification` pairing already defined in `templates/SCRUM_BOARD_SCHEMA.md` for exactly this situation ("scope overridden by a human"), rather than inventing a new field:
+4. **Record the override for audit**, reusing the existing `jenga_assigned` / `override_justification` pairing already defined in `$([ -f templates/SCRUM_BOARD_SCHEMA.md ] && echo templates/SCRUM_BOARD_SCHEMA.md || echo node_modules/@jenga-ai/agent/templates/SCRUM_BOARD_SCHEMA.md)` for exactly this situation ("scope overridden by a human"), rather than inventing a new field:
    - Set `jenga_assigned: false` (if not already `false`).
    - Set (or append to, if already present) `override_justification`:
      ```
@@ -368,7 +368,7 @@ After override validation (step 4.1) and before branching on `execution_scope` i
 
 After resolving the task context (step 4), passing override validation (step 4.1), and applying the `--trivial` dispatch-time override if present (step 4.1.5), read `execution_scope` from the task frontmatter.
 
-**Locked-task dispatch guard (defense-in-depth).** Before branching on `execution_scope` below, read `crucial_level` from the task frontmatter (per `templates/SCRUM_BOARD_SCHEMA.md`'s Crucial Flag Fields). If `crucial_level: locked`:
+**Locked-task dispatch guard (defense-in-depth).** Before branching on `execution_scope` below, read `crucial_level` from the task frontmatter (per `$([ -f templates/SCRUM_BOARD_SCHEMA.md ] && echo templates/SCRUM_BOARD_SCHEMA.md || echo node_modules/@jenga-ai/agent/templates/SCRUM_BOARD_SCHEMA.md)`'s Crucial Flag Fields). If `crucial_level: locked`:
 
 - This task MUST be routed through the inline execution path below — no worktree, no developer subagent — regardless of what `execution_scope` currently reads. This guards against a locked task reaching dispatch with a non-`inline` `execution_scope` (a race, a manually edited file, or a task added to a story's `tasks:` list after `skills/jenga/SKILL.md` Phase 0.5's Rule 4 last ran).
 - If `execution_scope` is already `inline`, proceed directly to the inline steps below — no correction needed.
@@ -389,10 +389,10 @@ After resolving the task context (step 4), passing override validation (step 4.1
 1. Read the task file and load its full content (description, acceptance criteria). Do NOT create a worktree. Do NOT spawn a developer subagent.
 2. Implement the task inline — make the required changes to files directly in the current session.
 3. Run the smoke test harness before committing anything:
-   - Run `bash scripts/smoke-harness.sh <changed_file>...`, passing the paths changed in step 2. With no arguments the harness infers them from `git diff --name-only HEAD`. It exits `0` on pass and `1` on failure.
-   - If `scripts/smoke-harness.sh` does not exist, log a warning and treat the result as a pass:
+   - Run `bash "$([ -f scripts/smoke-harness.sh ] && echo scripts/smoke-harness.sh || echo node_modules/@jenga-ai/agent/scripts/smoke-harness.sh)" <changed_file>...`, passing the paths changed in step 2. With no arguments the harness infers them from `git diff --name-only HEAD`. It exits `0` on pass and `1` on failure.
+   - If neither `scripts/smoke-harness.sh` nor `node_modules/@jenga-ai/agent/scripts/smoke-harness.sh` exists, log a warning and treat the result as a pass:
      ```
-     WARNING [<task_id>]: scripts/smoke-harness.sh not found. Smoke test skipped (stub pass).
+     WARNING [<task_id>]: smoke-harness.sh not found. Smoke test skipped (stub pass).
      ```
 4. **If the smoke test exits non-zero**:
    - **If this is a `--trivial`-forced run** (marker set in step 4.1.5 — and `crucial_level` is not `locked`, which never falls back, per 4.1.5's precedence note): do NOT write `status: Failed`. `--trivial` always forces `inline` with no softer "lightest safe tier" to fall back to first, so a smoke-harness failure here goes straight to the shared `#### Fallback to Full Task-Scope Pipeline` procedure below (origin: `trivial`). Do not proceed with the remaining inline steps below — the Fallback procedure takes over from here.
@@ -431,10 +431,10 @@ After resolving the task context (step 4), passing override validation (step 4.1
 1. **Spawn a developer subagent** (Agent tool, `subagent_type: "developer"`) with the same sender object and context payload as step 5 would use, but with an explicit instruction added to the dispatch prompt: **do not create a worktree** — implement directly against the current checkout (the session's existing working tree), not an isolated `.claude/worktrees/<slug>` copy. This is the one concrete difference from the step-5 `task` path: everything else about how the subagent implements the task (reading the task file, following acceptance criteria, following repo conventions) is unchanged.
 
 2. **After the developer subagent reports implementation complete**, run the smoke test harness using the same invocation convention as `### 4.2. Inline Execution Path`:
-   - Run `bash scripts/smoke-harness.sh <changed_file>...`, passing the paths the subagent changed. With no arguments the harness infers them from `git diff --name-only HEAD`. It exits `0` on pass and `1` on failure.
-   - If `scripts/smoke-harness.sh` does not exist, log a warning and treat the result as a pass:
+   - Run `bash "$([ -f scripts/smoke-harness.sh ] && echo scripts/smoke-harness.sh || echo node_modules/@jenga-ai/agent/scripts/smoke-harness.sh)" <changed_file>...`, passing the paths the subagent changed. With no arguments the harness infers them from `git diff --name-only HEAD`. It exits `0` on pass and `1` on failure.
+   - If neither `scripts/smoke-harness.sh` nor `node_modules/@jenga-ai/agent/scripts/smoke-harness.sh` exists, log a warning and treat the result as a pass:
      ```
-     WARNING [<task_id>]: scripts/smoke-harness.sh not found. Smoke test skipped (stub pass).
+     WARNING [<task_id>]: smoke-harness.sh not found. Smoke test skipped (stub pass).
      ```
 
 3. **If the smoke test passes**:
@@ -528,8 +528,8 @@ Additionally, if the completed work introduces user-facing changes, update `READ
 ### 7. After successful completion
 - Check for any `_INSTRUCTIONS.md` files in `project/instructions/` whose ID matches the completed task. If found, present them to the user and explain that these actions must be completed before the feature will work correctly.
 - Invoke the `/commit` skill to commit the work (if not already committed by the developer)
-- Run `bash scripts/todo_manager.sh remove '<task title>'` to remove the completed task from `project/todo.md`
-- Run `bash scripts/todo_manager.sh teardown` to delete `project/todo.md` if it is now effectively empty
+- Run `bash "$([ -f scripts/todo_manager.sh ] && echo scripts/todo_manager.sh || echo node_modules/@jenga-ai/agent/scripts/todo_manager.sh)" remove '<task title>'` to remove the completed task from `project/todo.md`
+- Run `bash "$([ -f scripts/todo_manager.sh ] && echo scripts/todo_manager.sh || echo node_modules/@jenga-ai/agent/scripts/todo_manager.sh)" teardown` to delete `project/todo.md` if it is now effectively empty
 
 ### 8. Loop
 Go back to step 1.

package/skills/j-doc-sync/SKILL.md

@@ -101,7 +101,7 @@ Every candidate identified above as "missing documentation for new things added
 1. **Check for `.publicignore` at the repo root.** Most projects using this framework will not have one (they haven't adopted `/mirror-public`) — if it's absent, **skip this entire sub-step**. Fall through to flagging every "missing documentation" candidate exactly as `3.` above already would, with no further filtering.
 2. **If `.publicignore` exists**, for each "missing documentation" candidate, determine its source path (relative to the repo root) and classify it by running:
    ```
-   scripts/check-publicignore-match.sh <path> [<path> ...]
+   bash "$([ -f scripts/check-publicignore-match.sh ] && echo scripts/check-publicignore-match.sh || echo node_modules/@jenga-ai/agent/scripts/check-publicignore-match.sh)" <path> [<path> ...]
    ```
    This reuses `/mirror-public`'s own `mirror.sh` matching logic (`rsync --exclude-from=.publicignore`) — a file this script reports `BLOCKED` is guaranteed to be a file `/mirror-public --dry-run` would also report as "would be blocked", and vice versa for `PUBLIC`. It needs no network access and does not require `/mirror-public` to be configured.
 3. **`BLOCKED`** → do not flag this candidate as missing documentation. It's private-only and will never ship to the public mirror, so public docs coverage is not applicable.
@@ -181,6 +181,17 @@ After all writes are done, print a summary:
 If nothing needed updating, print: `✅ Documentation is already in sync with the source.`
 If minification could not reach the target, note: `⚠️ docs/API.md reduced to X% (target was Y% — essential content limit reached).`
 
+### 8. GitHub Pages site follow-up (E41_S13)
+
+If this run updated `project/.wiki/documentation.md`, `project/.wiki/intro-guide.md`, or any
+`project/.wiki/concepts/*.md` file, also re-run `bash "$([ -f scripts/build-pages-site.sh ] && echo scripts/build-pages-site.sh || echo node_modules/@jenga-ai/agent/scripts/build-pages-site.sh)"` afterward. That
+script deterministically regenerates the GitHub Pages documentation site's wiki-derived pages
+(`docs/getting-started.md`, `docs/concepts.md`, `docs/skills.md`, `docs/agents.md`,
+`docs/hooks.md`, `docs/mcp-tools.md`, `docs/reference.md`) from the wiki content this step just
+updated — without re-running it, the Pages site silently drifts from the wiki the same way
+`README.md` and the wiki itself have drifted from each other before. Mention this in the
+summary output (e.g. `🔄 Re-ran build-pages-site.sh to refresh the Pages site`).
+
 ---
 
 ## Reference files

package/skills/j-idea/SKILL.md

@@ -36,7 +36,7 @@ This file is generated/synced by `scripts/generate-j-alias.sh idea` from `skills
 
 3. **Add to `project/ideas.md`** by running:
    ```
-   bash scripts/idea_manager.sh add '<idea>'
+   bash "$([ -f scripts/idea_manager.sh ] && echo scripts/idea_manager.sh || echo node_modules/@jenga-ai/agent/scripts/idea_manager.sh)" add '<idea>'
    ```
 
 4. **Ask the user**: "Capture another idea, or done?"

package/skills/j-init/SKILL.md

@@ -144,10 +144,11 @@ This script handles all scaffolding in one step:
 7. Creates `project/configs/scope-thresholds.json` with default execution-scope thresholds (consumed by `/jenga` and `/do`, which halt if it's missing)
 8. Creates `project/data/baselines.json`
 9. Creates `project/logs/events.json`
-10. Creates `docs/STRATEGY.md` — a strategic brief stub intended for investors, partners, and the product team
-11. Creates `CHANGELOG.md` from the shared template — a running log of notable changes, seeded with an `[Unreleased]` section
-12. 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
-13. Stages and commits all files with the message `init: scaffold project structure and workflow config`
+10. Creates `project/knowledge-graph/STUB_SCHEMA.md` from the shared template and `project/knowledge-graph/graph.json` seeded with empty `nodes`/`edges` arrays — consumed by `/uncharted`'s conversational elicitation flow
+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`
 
 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

package/skills/j-init/assets/directory_structure.txt

@@ -3,6 +3,7 @@ project/board/stories
 project/board/tasks
 project/instructions
 project/configs
+project/knowledge-graph
 project/data
 project/queue
 project/rapports/problems

package/skills/j-init/scripts/detect-existing-codebase.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/init/scripts/detect-existing-codebase.sh
+# skills/j-init/scripts/detect-existing-codebase.sh
 #
 # Deterministic front half of the /init "detect existing project state" step.
 # /init currently always scaffolds as though the target directory were empty.
@@ -12,7 +12,7 @@
 # This script answers exactly one question -- "what kind of directory is
 # this?" -- and nothing else. It never scaffolds, never prompts, never runs
 # /uncharted, and never modifies anything on disk. Deciding what to DO with
-# the verdict is agent judgement and lives in skills/init/SKILL.md.
+# the verdict is agent judgement and lives in skills/j-init/SKILL.md.
 #
 # ---------------------------------------------------------------------------
 # VERDICTS -- exactly one is printed on stdout, nothing else

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

@@ -8,9 +8,9 @@ VISIBILITY_SCRIPT="$SCRIPT_DIR/apply-project-visibility.sh"
 # ─── Resolve the package root that owns templates/ and lib/ ──────────────────
 # postinstall.js mirrors only skills/ and agents/ into .claude/ and .agents/ —
 # templates/ and lib/ are never copied there, so a script running from a
-# mirrored copy (.claude/skills/init/scripts/ or .agents/skills/init/scripts/)
+# mirrored copy (.claude/skills/j-init/scripts/ or .agents/skills/j-init/scripts/)
 # cannot reach its siblings via a fixed ../../../ climb the way it can in this
-# monorepo checkout, where init.sh actually lives at skills/init/scripts/ with
+# monorepo checkout, where init.sh actually lives at skills/j-init/scripts/ with
 # templates/ and lib/ three levels up. Consumers instead have them inside the
 # installed npm package.
 if [[ -d "$SCRIPT_DIR/../../../templates" ]]; then
@@ -81,6 +81,17 @@ echo '{}' > project/data/baselines.json
 echo "→ Creating events.json..."
 echo '[]' > project/logs/events.json
 
+# ─── 8.5. Create project/knowledge-graph/{STUB_SCHEMA.md,graph.json} ─────────
+# Consumed by skills/uncharted's conversational elicitation flow (`onboard`,
+# `segment --mode investigate`), which writes coarse graph nodes/edges to
+# graph.json per the stub schema — both must exist before that flow's first
+# write, per templates/KNOWLEDGE_GRAPH_STUB_SCHEMA_TEMPLATE.md's own header
+# comment (E20_S08_T01; replaced wholesale once E20_S01's real schema lands).
+echo "→ Copying knowledge-graph STUB_SCHEMA.md from template..."
+cp "$PKG_ROOT/templates/KNOWLEDGE_GRAPH_STUB_SCHEMA_TEMPLATE.md" project/knowledge-graph/STUB_SCHEMA.md
+echo "→ Creating project/knowledge-graph/graph.json..."
+echo '{"nodes": [], "edges": []}' > project/knowledge-graph/graph.json
+
 # ─── 9. Create docs/STRATEGY.md ──────────────────────────────────────────────
 echo "→ Creating docs/STRATEGY.md (strategic brief for investors, partners, and the product team)..."
 mkdir -p docs