@jenga-ai/agent 1.3.0 → 3.0.0

package/skills/j-todo/scripts/update_story_tasks.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+skills/j-todo/scripts/update_story_tasks.py
+
+Mechanically inserts a task ID into a story board file's `tasks:` frontmatter
+list, if it is not already present. Idempotent (a re-run with the same
+task_id is a no-op, exit 0).
+
+This is a pure text/frontmatter edit and does no board-wide validation beyond
+"frontmatter block exists" — it is intended to be invoked already wrapped in
+scripts/with-lock.sh, keyed to the story file, per templates/SCRUM_BOARD_SCHEMA.md's
+File Locking section (board frontmatter writes must go through the lock wrapper).
+
+Usage:
+    python3 skills/j-todo/scripts/update_story_tasks.py <story-file> <task-id>
+
+Exit codes:
+    0   success (task_id inserted, or already present)
+    1   usage error
+    2   story file has no parseable frontmatter block
+"""
+import sys
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print("Usage: update_story_tasks.py <story-file> <task-id>", file=sys.stderr)
+        return 1
+
+    path, task_id = sys.argv[1], sys.argv[2]
+
+    with open(path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    parts = content.split("---", 2)
+    if len(parts) < 3:
+        print(f"Error: {path} has no valid '---' frontmatter block", file=sys.stderr)
+        return 2
+
+    _, frontmatter, rest = parts
+    lines = frontmatter.split("\n")
+    task_line = f"  - {task_id}"
+
+    if any(line.strip() == task_line.strip() for line in lines):
+        print(f"No-op: {task_id} already present in {path}'s tasks: list")
+        return 0
+
+    idx = None
+    inline_empty_idx = None
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped == "tasks:":
+            idx = i
+            break
+        if stripped == "tasks: []":
+            inline_empty_idx = i
+            break
+
+    if inline_empty_idx is not None:
+        lines[inline_empty_idx] = "tasks:"
+        lines.insert(inline_empty_idx + 1, task_line)
+    elif idx is not None:
+        j = idx + 1
+        while j < len(lines) and lines[j].strip().startswith("- "):
+            j += 1
+        lines.insert(j, task_line)
+    else:
+        # No tasks: key found at all — append one at the end of the frontmatter,
+        # trimming any single trailing blank line first so formatting stays tidy.
+        if lines and lines[-1].strip() == "":
+            lines.pop()
+        lines.append("tasks:")
+        lines.append(task_line)
+        lines.append("")
+
+    new_frontmatter = "\n".join(lines)
+    new_content = "---" + new_frontmatter + "---" + rest
+
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(new_content)
+
+    print(f"Updated {path}: added {task_id} to tasks:")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -1,6 +1,6 @@
 ---
-name: uncharted
-description: Investigate code that has no Jenga board provenance — a foreign file, an external source being pulled in, or an entire pre-existing codebase — and give it a consistent understanding document plus proper board representation.
+name: j.uncharted
+description: Polyfill alias of the uncharted skill under a collision-safe directory name. Identical behavior to /uncharted — Investigate code that has no Jenga board provenance — a foreign file, an external source being pulled in, or an entire pre-existing codebase — and give it a consistent understanding document plus proper board representation. Use when the bare /uncharted form is shadowed by another tool's own built-in command of the same name.
 metadata:
   prefered_agent: scrum-master
 keywords:
@@ -12,6 +12,8 @@ keywords:
   - "import source"
   - "unlinked code"
   - "no board history"
+  - j-uncharted
+  - polyfill
 examples:
   - "what does this file actually do?"
   - "help me understand this directory I inherited"
@@ -20,10 +22,15 @@ examples:
   - "this code has no board history, get it onto the board"
   - "analyse the legacy module nobody understands"
   - "onboard this existing codebase"
+  - "j-uncharted"
 ---
 
 # Uncharted — Investigative Workflow for Foreign & Pre-Existing Code
 
+This skill is a literal-directory-name duplicate of `skills/uncharted/`. It exists so that `/j-uncharted` (and `j.j-uncharted`) give a guaranteed-unshadowed way to reach the same flow as `/uncharted`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/uncharted` 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 uncharted` from `skills/uncharted/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 `/uncharted` is the entry point for code with **no board provenance** — code that was never planned, decomposed, or executed through the Jenga workflow.
 
 It fills a gap the existing investigative skills leave open:
@@ -62,7 +69,7 @@ Every mode runs the same shared investigative engine and emits the same understa
 
 ## Shared Investigative Engine
 
-All three modes call the same engine rather than reimplementing analysis. Per the Skill Implementation Principle in `CLAUDE.md`, the deterministic work lives in scripts under `skills/uncharted/scripts/`, not in this file:
+All three modes call the same engine rather than reimplementing analysis. Per the Skill Implementation Principle in `CLAUDE.md`, the deterministic work lives in scripts under `skills/j-uncharted/scripts/`, not in this file:
 
 | Script | Responsibility | Implemented by |
 |---|---|---|
@@ -74,7 +81,7 @@ All three modes call the same engine rather than reimplementing analysis. Per th
 **Invoke `run-engine.sh`, never the individual detectors.** It is the only supported entry point; calling a detector directly gets you raw JSON and no document.
 
 ```bash
-DOC=$(bash skills/uncharted/scripts/run-engine.sh --mode segment <target>)
+DOC=$(bash skills/j-uncharted/scripts/run-engine.sh --mode segment <target>)
 ```
 
 | Option | Effect |
@@ -106,7 +113,7 @@ Do not restate in prose what these scripts do step by step, and do not reimpleme
 
 ## Output: the Understanding Document
 
-Every mode produces exactly one document per target, rendered from `skills/uncharted/assets/UNDERSTANDING_DOC_TEMPLATE.md`.
+Every mode produces exactly one document per target, rendered from `skills/j-uncharted/assets/UNDERSTANDING_DOC_TEMPLATE.md`.
 
 **Where it goes:** `project/rapports/analysis/`, named `uncharted-<mode>-<slug>-<YYYYMMDDTHHMMSSZ>.md`. Nothing is ever overwritten — a name collision gets a `-2`, `-3`… suffix, so repeated runs against one target leave a diffable history.
 
@@ -170,7 +177,7 @@ Runs once per elicitation, between discovery and the first Investigative Mode di
 
 ```bash
 discover-subsystems.sh <root> | jq -r '.candidates[].path' \
-  | bash skills/uncharted/scripts/directory-triage.sh <root>
+  | bash skills/j-uncharted/scripts/directory-triage.sh <root>
 ```
 
 Read `ignored` (already excluded by `.gitignore`, or matching the fixed vendor/generated pattern list — see the script's own header for the full list) and `remaining`. This is a mechanical classification; do not second-guess it or re-run judgement over an `ignored` entry.
@@ -211,7 +218,7 @@ Runs once per surviving candidate (a subsystem, a named flow, a directory) after
 4. **Confirm/correct, one round per call to `elicitation-state.sh turn`.** For a node requiring confirmation, present the draft and ask the user to confirm or correct it (per the Interaction Pattern in `CLAUDE.md` — confirm / correct-with-detail / defer as "unconfirmed" / other). Each round, call:
 
    ```bash
-   bash skills/uncharted/scripts/elicitation-state.sh turn --id <elicitation-id> --node <node-id>
+   bash skills/j-uncharted/scripts/elicitation-state.sh turn --id <elicitation-id> --node <node-id>
    ```
 
    Exit `0` means keep looping (cap not yet reached) if the user corrected rather than confirmed. Exit `3` means **the hard turn cap has been reached** — the node is now marked `flagged` in the state file. **Do not loop again on that node.** Instead present it as unresolved and offer an explicit choice rather than looping indefinitely (solution assessment, Problem 10, Solution A — RECOMMENDED):
@@ -228,7 +235,7 @@ Runs once per surviving candidate (a subsystem, a named flow, a directory) after
 5. **On convergence** (confirmed, corrected-and-accepted, or resolved via the cap choice above), call:
 
    ```bash
-   bash skills/uncharted/scripts/elicitation-state.sh converge --id <elicitation-id> --node <node-id> --note "<one-line summary of what was confirmed>"
+   bash skills/j-uncharted/scripts/elicitation-state.sh converge --id <elicitation-id> --node <node-id> --note "<one-line summary of what was confirmed>"
    ```
 
    then write the node/edge to `project/knowledge-graph/graph.json` per the stub schema, and checkpoint the elicitation state (next section) — **after every converged node**, not only at the end of the whole run.
@@ -240,7 +247,7 @@ A whole-codebase `onboard` conversation, or an investigation of a large director
 - **`init` once, at the start of an elicitation:**
 
   ```bash
-  bash skills/uncharted/scripts/elicitation-state.sh init --id <elicitation-id> --target "<path or description>" --cap 5
+  bash skills/j-uncharted/scripts/elicitation-state.sh init --id <elicitation-id> --target "<path or description>" --cap 5
   ```
 
   Idempotent — safe to call again on a resumed `<elicitation-id>` without resetting progress. Choose `<elicitation-id>` so it is stable and re-derivable across sessions (e.g. `onboard-<root-slug>-<date>`, or `segment-investigate-<target-slug>`), since a resuming session must be able to reconstruct it to call `init` again.
@@ -288,7 +295,7 @@ Unchanged from before E20_S08_T03 — every step below is exactly what `segment`
 **Step 1 — Resolve the target.** Deterministic; do not eyeball it.
 
 ```bash
-bash skills/uncharted/scripts/resolve-segment-target.sh --json-only "<path-or-description>"
+bash skills/j-uncharted/scripts/resolve-segment-target.sh --json-only "<path-or-description>"
 ```
 
 It returns one `results[]` record. Read three fields:
@@ -310,7 +317,7 @@ It returns one `results[]` record. Read three fields:
 **Step 2 — Run the engine** on the resolved absolute path:
 
 ```bash
-DOC=$(bash skills/uncharted/scripts/run-engine.sh --mode segment "<resolved target>")
+DOC=$(bash skills/j-uncharted/scripts/run-engine.sh --mode segment "<resolved target>")
 ```
 
 Options, streams, and exit codes are in **Shared Investigative Engine** above — do not restate them here, and do not reimplement enumeration, dependency, or test detection. Two mode-specific readings:
@@ -332,7 +339,7 @@ List `project/board/epics/` and apply the normal scrum-master intake rule (`agen
 
 A new epic is the last option, not the default, and needs a stated reason. Record the epics you weighed and rejected — "none fit" is a claim the user should be able to check.
 
-**Step 5 — Draft the proposal** using `skills/uncharted/assets/SEGMENT_PROPOSAL_TEMPLATE.md`. Its six headings are fixed; fill every one of them. Two things it will not let you skip:
+**Step 5 — Draft the proposal** using `skills/j-uncharted/assets/SEGMENT_PROPOSAL_TEMPLATE.md`. Its six headings are fixed; fill every one of them. Two things it will not let you skip:
 
 - **Every proposed task carries `execution_scope` and a non-empty `scope_rationale`** containing a file-count or line-count claim, assigned against `project/configs/scope-thresholds.json` rather than by feel — `inline` at or under 1 file / 20 lines, `story` when tasks share files across the story (up to 5 files), `task` otherwise. Never self-assign `execution_scope: epic`: it requires `epic_scope_approval: true`, which only a human sets. Propose `story` and say the task looks bigger instead. Field semantics live in `templates/SCRUM_BOARD_SCHEMA.md` — read them there, do not paraphrase them here.
 - **The document's `Open Questions` carry over verbatim**, not re-derived, each with who can answer it and whether it blocks confirmation. A blocking question is resolved *before* the proposal is accepted, because the breakdown depends on its answer.
@@ -371,7 +378,7 @@ Shape, field names, and file naming come from `templates/SCRUM_BOARD_SCHEMA.md`.
 Then prove it mechanically rather than asserting it:
 
 ```bash
-bash skills/uncharted/scripts/validate-proposed-items.sh <every file just written>
+bash skills/j-uncharted/scripts/validate-proposed-items.sh <every file just written>
 ```
 
 It runs `scripts/validate-board.sh` over every file and `scripts/validate-story-format.sh` over every story file, and exits non-zero listing **each** failure — not just the first, because deciding whether to repair or roll back needs the whole list. Exit 2 means a usage error or a missing validator, not a bad board file.
@@ -395,7 +402,7 @@ New in **E20_S08_T03**. Produces a plain-language understanding plus graph nodes
 **Step 3 — Convergence loop.** Run the shared Convergence Loop procedure above. For a single-file target this is one node; for a directory target (after triage) it is one node per surviving candidate. Initialize persistence first:
 
 ```bash
-bash skills/uncharted/scripts/elicitation-state.sh init --id "segment-investigate-$(basename "$RESOLVED_TARGET")-$(date -u +%Y%m%d)" --target "$RESOLVED_TARGET"
+bash skills/j-uncharted/scripts/elicitation-state.sh init --id "segment-investigate-$(basename "$RESOLVED_TARGET")-$(date -u +%Y%m%d)" --target "$RESOLVED_TARGET"
 ```
 
 **Step 4 — On convergence, write the graph and the board item.** Write each converged node/edge to `project/knowledge-graph/graph.json` per the stub schema (`source: "human"`), then present a single `[ARCH]`-tagged board item proposal — epic, story, or task, whichever level fits what was actually investigated (a single flow is usually task-scale; a whole subsystem may warrant a story or, rarely, an epic) — and stop at the same kind of confirmation gate the delivery-shaped path's Step 6 uses (accept / revise / discard / other). **Nothing is written to `project/board/` before that gate is confirmed**, matching the delivery-shaped path's own "nothing written before option 1" guarantee. On acceptance, write the board item and call `elicitation-state.sh complete`.
@@ -416,7 +423,7 @@ Pull an external source into the repo, then investigate it as a segment.
 **Step 1 — Acquire into staging.** Deterministic; do not hand-roll a clone or a copy.
 
 ```bash
-SUMMARY_JSON=$(bash skills/uncharted/scripts/import-source.sh --json-only "<source>")
+SUMMARY_JSON=$(bash skills/j-uncharted/scripts/import-source.sh --json-only "<source>")
 ```
 
 `<source>` is a git URL, a local path **outside** this repo, or `-` (with the snippet piped
@@ -436,7 +443,7 @@ itself on failure).
 destination proposal is presented *alongside* these findings, never before them.
 
 ```bash
-PROVENANCE_JSON=$(bash skills/uncharted/scripts/inspect-provenance.sh \
+PROVENANCE_JSON=$(bash skills/j-uncharted/scripts/inspect-provenance.sh \
   --origin-source "$(echo "$SUMMARY_JSON" | jq -r .source)" \
   --origin-type   "$(echo "$SUMMARY_JSON" | jq -r .source_type)" \
   --origin-ref    "$(echo "$SUMMARY_JSON" | jq -r '.git_ref // ""')" \
@@ -616,7 +623,7 @@ convention to be onboarded. This guarantee is enforced in three independent plac
 stated here:
 
 1. **This prohibition**, read by any agent driving `onboard` mode.
-2. **A structural write-path guard** in `skills/uncharted/scripts/write-backfilled-epics.sh` — its
+2. **A structural write-path guard** in `skills/j-uncharted/scripts/write-backfilled-epics.sh` — its
    `--epics-dir` and `--json-out` destinations are canonicalised and checked against
    `<repo-root>/project/` *before* any file is written, with no flag able to point either one
    outside it. A path that resolves outside `project/` is a hard failure (exit 3), nothing
@@ -631,7 +638,7 @@ New in **E20_S08_T03**. Runs when `onboard` is invoked without `--legacy`.
 **Step 1 — discovery stays scripted.** Run the exact same deterministic discovery chain the legacy pipeline uses — `discover-subsystems.sh` — unchanged. Evidence-gathering is not where this rework touches anything; only what happens with the output differs.
 
 ```bash
-bash skills/uncharted/scripts/discover-subsystems.sh <root>
+bash skills/j-uncharted/scripts/discover-subsystems.sh <root>
 ```
 
 **Step 2 — directory triage.** Feed the discovery output's candidate paths into the shared Directory Triage procedure (see Conversational Elicitation above), and stop at its confirmation gate before anything else happens.
@@ -639,7 +646,7 @@ bash skills/uncharted/scripts/discover-subsystems.sh <root>
 **Step 3 — initialize persistence.**
 
 ```bash
-bash skills/uncharted/scripts/elicitation-state.sh init --id "onboard-$(basename "$(cd "$root" && pwd)")-$(date -u +%Y%m%d)" --target "<root>" --cap 5
+bash skills/j-uncharted/scripts/elicitation-state.sh init --id "onboard-$(basename "$(cd "$root" && pwd)")-$(date -u +%Y%m%d)" --target "<root>" --cap 5
 ```
 
 **Step 4 — convergence loop, once per surviving candidate.** Run the shared Convergence Loop procedure (see Conversational Elicitation above) for each candidate that survived triage — this is where the legacy pipeline's `apply-subsystem-cap.sh` and `write-backfilled-epics.sh` would have silently produced a capped set of `provenance: backfilled` epics; the conversational default asks about each one instead, subject to the same risk-weighted gating and hard turn cap. There is deliberately **no subsystem cap** on the conversational path — the turn cap already bounds cost per candidate, and capping the *candidate count* the way the legacy path does would silently drop subsystems from a human-in-the-loop conversation the same way the legacy path drops them from an unattended one, which defeats the point of asking. A codebase with far more subsystems than is practical to walk through conversationally in one sitting is exactly the multi-session case Multi-Session Persistence exists for — pause, resume across sessions, rather than truncate the candidate list.
@@ -656,12 +663,12 @@ Everything below is `E40_S04`'s original, fully-automated, zero-prompt pipeline
 
 Live as of `E40_S04_T03`. `onboard` does **not** create one epic per discovered subsystem — a
 40-subsystem repository would bury the board on day one. It caps how many become epics, and
-`skills/uncharted/scripts/apply-subsystem-cap.sh` applies that cap to `discover-subsystems.sh`'s
+`skills/j-uncharted/scripts/apply-subsystem-cap.sh` applies that cap to `discover-subsystems.sh`'s
 ranked output:
 
 ```bash
-bash skills/uncharted/scripts/discover-subsystems.sh <root> \
-  | bash skills/uncharted/scripts/apply-subsystem-cap.sh --rapport "$DOC"
+bash skills/j-uncharted/scripts/discover-subsystems.sh <root> \
+  | bash skills/j-uncharted/scripts/apply-subsystem-cap.sh --rapport "$DOC"
 ```
 
 It emits JSON with two explicit arrays — `kept` (the subsystems that become backfilled epics) and
@@ -702,7 +709,7 @@ re-running `onboard` with a higher `--cap`.
 
 #### Generating the backfilled epics
 
-Live as of `E40_S04_T04`. `skills/uncharted/scripts/write-backfilled-epics.sh` is the only thing
+Live as of `E40_S04_T04`. `skills/j-uncharted/scripts/write-backfilled-epics.sh` is the only thing
 that actually writes backfilled epics to the board — it consumes `apply-subsystem-cap.sh`'s
 `kept` array and renders one epic file per entry, following the Epic format in
 `templates/SCRUM_BOARD_SCHEMA.md` exactly (`provenance: backfilled`, `status: Pending`, an empty
@@ -710,9 +717,9 @@ that actually writes backfilled epics to the board — it consumes `apply-subsys
 framed around understanding and integration, never original construction):
 
 ```bash
-bash skills/uncharted/scripts/discover-subsystems.sh <root> \
-  | bash skills/uncharted/scripts/apply-subsystem-cap.sh --rapport "$DOC" \
-  | bash skills/uncharted/scripts/write-backfilled-epics.sh
+bash skills/j-uncharted/scripts/discover-subsystems.sh <root> \
+  | bash skills/j-uncharted/scripts/apply-subsystem-cap.sh --rapport "$DOC" \
+  | bash skills/j-uncharted/scripts/write-backfilled-epics.sh
 ```
 
 | Option | Effect |
@@ -775,7 +782,7 @@ above have been written (or confirmed skipped). Its job is to close the gap the
 describes: a project adopting Jenga should not end up with a populated board sitting underneath a
 `PROJECT_SUMMARY.md` that still reads as if the codebase were empty.
 
-**This is a scrum-master action, not a script.** Nothing under `skills/uncharted/scripts/` writes
+**This is a scrum-master action, not a script.** Nothing under `skills/j-uncharted/scripts/` writes
 `PROJECT_SUMMARY.md`, and the developer agent never touches it either — both `agents/developer.md`
 and `agents/scrum-master.md` already establish `PROJECT_SUMMARY.md` as scrum-master-owned, sole
 writer, no exceptions, and `onboard` does not get to be the exception just because the content
@@ -865,7 +872,7 @@ These hold across every mode:
 - **Confirm before writing to the board.** Proposals are presented for approval first, consistent with the brainstorm-before-commit convention. Since `E20_S08_T03`, this also covers Directory Triage's confirmation gate and each converged node's graph/board write in the conversational elicitation flow — same convention, applied to a new output type (graph nodes), not a new exception to it.
 - **No new rapport type.** Understanding documents use the existing `analysis` type and land in `project/rapports/analysis/`. Conversational elicitation's output (graph nodes + `[ARCH]` board items) is not an understanding document and does not need one — see Conversational Elicitation above for what it produces instead.
 - **Never invent findings.** If the evidence does not support a conclusion, say so under Open Questions (delivery-shaped/legacy paths) or state the uncertainty plainly in the node itself (conversational paths — see Human-Oracle-Availability Limitation above).
-- **Deterministic work belongs in `skills/uncharted/scripts/`**, agent judgement belongs here.
+- **Deterministic work belongs in `skills/j-uncharted/scripts/`**, agent judgement belongs here.
 - **Existing zero-prompt behavior is never silently retired.** `onboard --legacy` and `segment --mode delivery` reproduce exactly what `/uncharted` did before `E20_S08_T03`, with no behavior drift for a caller who keeps using them.
 
 ---

package/skills/{uncharted → j-uncharted}/assets/UNDERSTANDING_DOC_TEMPLATE.md

@@ -4,7 +4,7 @@
   OUTPUT CONTRACT — /uncharted shared investigative engine.
 
   Every mode (`segment`, `import`, `onboard`) emits this exact document shape.
-  It is rendered by `skills/uncharted/scripts/run-engine.sh` and written to
+  It is rendered by `skills/j-uncharted/scripts/run-engine.sh` and written to
   `project/rapports/analysis/` using the existing `analysis` rapport type
   defined in `templates/SCRUM_BOARD_SCHEMA.md`.
 
@@ -34,7 +34,7 @@
 
 **Mode:** {{MODE}}
 **Generated:** {{TIMESTAMP}}
-**Engine:** `skills/uncharted/scripts/run-engine.sh`
+**Engine:** `skills/j-uncharted/scripts/run-engine.sh`
 
 ---
 

package/skills/{uncharted → j-uncharted}/scripts/detect-dependencies.sh

@@ -19,7 +19,7 @@
 # no git state. Its only outputs are JSON on stdout and diagnostics on stderr.
 #
 # ---------------------------------------------------------------------------
-# Output contract (stdout, JSON) — consumed by skills/uncharted/scripts/run-engine.sh
+# Output contract (stdout, JSON) — consumed by skills/j-uncharted/scripts/run-engine.sh
 # ---------------------------------------------------------------------------
 # {
 #   "script": "detect-dependencies.sh",

package/skills/{uncharted → j-uncharted}/scripts/detect-tests.sh

@@ -28,7 +28,7 @@
 # no git state. Its only outputs are JSON on stdout and diagnostics on stderr.
 #
 # ---------------------------------------------------------------------------
-# Output contract (stdout, JSON) — consumed by skills/uncharted/scripts/run-engine.sh
+# Output contract (stdout, JSON) — consumed by skills/j-uncharted/scripts/run-engine.sh
 # ---------------------------------------------------------------------------
 # {
 #   "script": "detect-tests.sh",

package/skills/{uncharted → j-uncharted}/scripts/directory-triage.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/uncharted/scripts/directory-triage.sh
+# skills/j-uncharted/scripts/directory-triage.sh
 #
 # Deterministic front half of the directory-triage step (E20_S08_T03) that
 # sits between discovery and any developer/tester Investigative Mode
@@ -90,7 +90,7 @@
 # does not attempt content-based judgement (reading file contents to guess
 # "this looks like SOAP mock-ups") at all. That pass is agent judgement, per
 # the Skill Implementation Principle in CLAUDE.md, and lives in
-# skills/uncharted/SKILL.md's Directory Triage subsection, not here.
+# skills/j-uncharted/SKILL.md's Directory Triage subsection, not here.
 #
 # ---------------------------------------------------------------------------
 # EXIT CODES
@@ -124,7 +124,7 @@ Classifies candidate directories under <root> into:
                .venv, venv, __pycache__, .next, coverage, target, .git,
                .tox, .mypy_cache, .pytest_cache, .cache, *.egg-info)
   - remaining: everything else — the input to the agent-judgement
-               generalize-list pass documented in skills/uncharted/SKILL.md
+               generalize-list pass documented in skills/j-uncharted/SKILL.md
 
 Options:
   --root DIR       Root the candidates are resolved against (or give it as

package/skills/{uncharted → j-uncharted}/scripts/elicitation-state.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/uncharted/scripts/elicitation-state.sh
+# skills/j-uncharted/scripts/elicitation-state.sh
 #
 # Deterministic persistence + turn-cap counting for `/uncharted`'s
 # conversational convergence loop (E20_S08_T03) — the "propose understanding,
@@ -27,7 +27,7 @@
 # This script performs NO judgement — it does not decide what to ask, what
 # counts as high-impact, or when understanding has actually converged. It
 # only counts turns, tracks status, and persists whatever the agent asks it
-# to persist. All of that judgement lives in skills/uncharted/SKILL.md's
+# to persist. All of that judgement lives in skills/j-uncharted/SKILL.md's
 # Convergence Loop subsection.
 #
 # ---------------------------------------------------------------------------
@@ -89,7 +89,7 @@
 #       Set status "paused" and update "updated_at". The caller (the agent
 #       driving `/uncharted`) is responsible for also writing a scrum-master
 #       SessionEnd handoff with status "elicitation_paused" and this state
-#       file's path, per skills/uncharted/SKILL.md's Multi-Session
+#       file's path, per skills/j-uncharted/SKILL.md's Multi-Session
 #       Persistence subsection — this script only updates the state file
 #       itself, it does not write handoffs.
 #

package/skills/{uncharted → j-uncharted}/scripts/enumerate-target.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# skills/uncharted/scripts/enumerate-target.sh
+# skills/j-uncharted/scripts/enumerate-target.sh
 #
 # Read-only target resolution and structure enumeration for the /uncharted investigative engine.
 #

package/skills/{uncharted → j-uncharted}/scripts/import-source.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/uncharted/scripts/import-source.sh
+# skills/j-uncharted/scripts/import-source.sh
 #
 # Acquisition half of `/uncharted import`. Fetches an external source into a
 # STAGING directory only — it never places anything at a final destination

package/skills/{uncharted → j-uncharted}/scripts/inspect-provenance.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/uncharted/scripts/inspect-provenance.sh
+# skills/j-uncharted/scripts/inspect-provenance.sh
 #
 # Provenance surface for `/uncharted import`'s placement-confirmation gate
 # (E40_S03_T02). Given a staged source -- the `content_path` that

package/skills/{uncharted → j-uncharted}/scripts/resolve-segment-target.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/uncharted/scripts/resolve-segment-target.sh
+# skills/j-uncharted/scripts/resolve-segment-target.sh
 #
 # Deterministic front half of `/uncharted segment`. Given the raw argument the
 # user typed, it answers two mechanical questions so the agent never has to
@@ -13,7 +13,7 @@
 # It resolves, it classifies, it reports. It NEVER writes anything, never runs
 # the engine, and never touches application code. Deciding what to do with the
 # answer — which candidate to pick, whether the segment is worth investigating
-# — is agent judgement and lives in `skills/uncharted/SKILL.md`.
+# — is agent judgement and lives in `skills/j-uncharted/SKILL.md`.
 #
 # ---------------------------------------------------------------------------
 # BOARD-LINKAGE CHECK — the reusable interface
@@ -51,7 +51,7 @@
 # (`[A-Za-z0-9_./-]+`, trailing `.`/`-` stripped so a filename ending a sentence
 # still counts). A board file references the path when one of its tokens either
 # equals the path or is a DESCENDANT of it — so `skills/uncharted` is referenced
-# by a board item that only names `skills/uncharted/scripts/run-engine.sh`.
+# by a board item that only names `skills/j-uncharted/scripts/run-engine.sh`.
 #
 # This is a path-boundary test, not a substring test: `docs/hooks` does not make
 # `hooks` linked, and `src/app.js` does not make `src/app` linked.
@@ -343,7 +343,7 @@ def load_board():
 
     Every path-like run in a board file is registered under itself AND under each of its
     ancestor directories, so `skills/uncharted` is found via a board item that only ever names
-    `skills/uncharted/scripts/run-engine.sh`.
+    `skills/j-uncharted/scripts/run-engine.sh`.
     """
     docs = []
     index = {}
@@ -382,7 +382,7 @@ def load_board():
                 for k in range(1, len(parts) + 1):
                     prefix = "/".join(parts[:k])
                     # The token itself is registered too, not just its ancestors -- an exact
-                    # mention of `skills/uncharted/SKILL.md` must make that file linked.
+                    # mention of `skills/j-uncharted/SKILL.md` must make that file linked.
                     if not prefix or prefix in seen_prefixes:
                         continue
                     seen_prefixes.add(prefix)

package/skills/{uncharted → j-uncharted}/scripts/run-engine.sh

@@ -7,7 +7,7 @@
 # This is the ONE script the calling agent invokes. It does not reimplement any analysis:
 # it orchestrates the three deterministic detectors delivered by E40_S01_T02/T03, merges
 # their JSON, renders the understanding document from
-# skills/uncharted/assets/UNDERSTANDING_DOC_TEMPLATE.md, writes it into
+# skills/j-uncharted/assets/UNDERSTANDING_DOC_TEMPLATE.md, writes it into
 # project/rapports/analysis/, and prints the written path — and nothing else — on stdout.
 #
 #   enumerate-target.sh     → Target + Structure sections

package/skills/{uncharted → j-uncharted}/scripts/validate-proposed-items.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/uncharted/scripts/validate-proposed-items.sh
+# skills/j-uncharted/scripts/validate-proposed-items.sh
 #
 # Post-write gate for `/uncharted segment` Step 7. Given the board files a
 # confirmed proposal just wrote, it answers one mechanical question: do these
@@ -9,7 +9,7 @@
 # It validates. It NEVER writes, moves, or repairs a board file, and it has no
 # opinion about content — only about format. Deciding what to do with a failure
 # (fix and re-run, or roll the write back) is agent judgement and lives in
-# `skills/uncharted/SKILL.md`.
+# `skills/j-uncharted/SKILL.md`.
 #
 #   Usage: validate-proposed-items.sh <board-file> [more-files...]
 #

package/skills/{uncharted → j-uncharted}/scripts/write-backfilled-epics.sh

@@ -18,7 +18,7 @@
 # application code. Its entire output surface is project/board/, project/rapports/analysis/,
 # and project/PROJECT_SUMMARY.md. This script is the one that actually touches disk in the
 # epic-generation step, so it is where that guarantee is made STRUCTURAL rather than only
-# documented in skills/uncharted/SKILL.md:
+# documented in skills/j-uncharted/SKILL.md:
 #
 #   - The epics directory (--epics-dir, default <repo-root>/project/board/epics) and the
 #     --json-out path, if given, are both canonicalised and checked BEFORE any file is written.

package/skills/j-wtf/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: j.wtf
+description: Polyfill alias of the wtf skill under a collision-safe directory name. Identical behavior to /wtf — Alias of /clearify — clarifies ambiguous, dense, or under-specified prompts and conversation on request. This folder exists only so the `/wtf` slash command resolves to a skill; behaviour is identical to `/clearify`. Use when the bare /wtf form is shadowed by another tool's own built-in command of the same name.
+keywords:
+  - wtf
+  - confused
+  - huh
+  - what does this mean
+  - I'm lost
+  - j-wtf
+  - polyfill
+examples:
+  - "wtf"
+  - "wtf does this mean"
+  - "wtf is going on here"
+  - "j-wtf"
+---
+
+# WTF — Alias of /clearify
+
+This skill is a literal-directory-name duplicate of `skills/wtf/`. It exists so that `/j-wtf` (and `j.j-wtf`) give a guaranteed-unshadowed way to reach the same flow as `/wtf`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/wtf` 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 wtf` from `skills/wtf/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
+## Instructions
+
+`/wtf` is an alias of `/clearify`. Follow `skills/clearify/SKILL.md` in full — do not duplicate or reimplement its ambiguity-detection logic here. Read that file's `## Instructions` section and execute it exactly as written, using whatever prompt or conversation context is attached to this `/wtf` invocation.

package/skills/jenga/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: jenga
+name: j.jenga
 description: Interactive-by-default board orchestrator with a fully automated escape hatch. Bare `/jenga` renders a picker and confirmation tree before scoping the run; `/jenga <ids>` resolves an explicit fuzzy-ID scope and confirms it; `/jenga *` reproduces the original zero-prompt behavior — decomposing any unbroken Epics into Stories, any unbroken Stories into Tasks, queuing all unqueued Tasks into todo.md, then executing every eligible item with no user prompts — until the board is fully started.
 keywords:
   - jenga