@jenga-ai/agent 1.3.0 → 3.0.0

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

@@ -1,12 +1,19 @@
 ---
-name: reconcile
-description: Reconcile the scrum board with actual implementation state. Cross-checks every task's board status against git history and worktrees, merges orphaned worktree branches, demotes unimplemented "Done" items, promotes secretly-implemented items, flags code with no board provenance and offers /uncharted segment for it, and cleans stale entries from todo.md. Use when the board feels out of sync, after a big merge session, when tasks were completed outside the normal workflow, or when todo.md has grown stale. Trigger on phrases like "sync the board", "clean up the board", "reconcile", "board is out of date", "todo is stale", or "check what's really done".
+name: j.reconcile
+description: Polyfill alias of the reconcile skill under a collision-safe directory name. Identical behavior to /reconcile — Reconcile the scrum board with actual implementation state. Cross-checks every task's board status against git history and worktrees, merges orphaned worktree branches, demotes unimplemented "Done" items, promotes secretly-implemented items, flags code with no board provenance and offers /uncharted segment for it, and cleans stale entries from todo.md. Use when the board feels out of sync, after a big merge session, when tasks were completed outside the normal workflow, or when todo.md has grown stale. Trigger on phrases like "sync the board", "clean up the board", "reconcile", "board is out of date", "todo is stale", or "check what's really done". Use when the bare /reconcile form is shadowed by another tool's own built-in command of the same name.
 metadata:
   prefered_agent: scrum-master
+keywords:
+  - j-reconcile
+  - polyfill
 ---
 
 # Reconcile — Board ↔ Code Synchronisation
 
+This skill is a literal-directory-name duplicate of `skills/reconcile/`. It exists so that `/j-reconcile` (and `j.j-reconcile`) give a guaranteed-unshadowed way to reach the same flow as `/reconcile`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/reconcile` 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 reconcile` from `skills/reconcile/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 Walks the full board (epics → stories → tasks), verifies each item's status against what actually exists in git, and fixes any drift. Also cleans `project/todo.md` of entries that are already done. Then runs the same check in reverse — code that exists with no board item and no EST-tagged commit behind it — and offers `/uncharted segment` for what it finds.
 
 ## Scope argument
@@ -35,7 +42,7 @@ Omitting the argument entirely keeps today's full-board behavior completely unch
 phase below.
 
 Scope resolution itself is deterministic and handled entirely by
-`skills/reconcile/scripts/resolve-reconcile-scope.sh` (see Phase 0 immediately below) — this skill
+`skills/j-reconcile/scripts/resolve-reconcile-scope.sh` (see Phase 0 immediately below) — this skill
 only interprets that script's output; it does not re-parse scope arguments or re-derive range
 expansion.
 
@@ -50,7 +57,7 @@ Before touching anything else, resolve the scope argument (if any — see "Scope
 into a concrete set of epic/story/task ids:
 
 ```bash
-skills/reconcile/scripts/resolve-reconcile-scope.sh <scope-argument>
+skills/j-reconcile/scripts/resolve-reconcile-scope.sh <scope-argument>
 ```
 
 Omit `<scope-argument>` entirely for an unscoped, full-board run (the script's own no-argument
@@ -176,7 +183,7 @@ Phases 2 and 3 ask "does this board item exist in the code?". This phase asks th
 Run:
 
 ```bash
-skills/reconcile/scripts/detect-unlinked-code.sh
+skills/j-reconcile/scripts/detect-unlinked-code.sh
 ```
 
 It emits a single JSON object and exits `0` whether or not it finds anything; read

package/skills/{reconcile → j-reconcile}/scripts/detect-unlinked-code.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/reconcile/scripts/detect-unlinked-code.sh
+# skills/j-reconcile/scripts/detect-unlinked-code.sh
 #
 # The inverse half of `/reconcile`. The normal pass asks "does this board item
 # exist in the code?"; this asks "does this code exist on the board?" and finds
@@ -31,7 +31,7 @@
 # It scans, it classifies, it reports. It NEVER writes anything, never touches
 # the board, and never invokes `/uncharted`. Deciding which groups are worth
 # investigating and presenting the offer is agent judgement and lives in
-# `skills/reconcile/SKILL.md`.
+# `skills/j-reconcile/SKILL.md`.
 #
 # ---------------------------------------------------------------------------
 # SIGNAL A IS BORROWED, NOT REBUILT

package/skills/{reconcile → j-reconcile}/scripts/resolve-reconcile-scope.sh

@@ -1,10 +1,10 @@
 #!/usr/bin/env bash
 # ---------------------------------------------------------------------------
-# skills/reconcile/scripts/resolve-reconcile-scope.sh
+# skills/j-reconcile/scripts/resolve-reconcile-scope.sh
 #
 # Deterministic scope-argument resolver backing `/reconcile`'s new scope
 # argument (story E17_S07). This script owns ALL scope-argument parsing and
-# id-range expansion for `/reconcile` — `skills/reconcile/SKILL.md` (wired in
+# id-range expansion for `/reconcile` — `skills/j-reconcile/SKILL.md` (wired in
 # the sibling task E17_S07_T02) only interprets this script's structured
 # stdout output; it must not re-derive any parsing or resolution logic
 # inline.
@@ -124,7 +124,7 @@
 #     "epic_ids":         ["E12"],
 #     "story_ids":        ["E12_S03", "E12_S04", "E12_S05"],
 #     "task_ids":         ["E12_S03_T01", "..."],
-#     "owned_path_hints": ["skills/reconcile/", "..."]
+#     "owned_path_hints": ["skills/j-reconcile/", "..."]
 #   }
 #
 #   scope_type "full"   epic_ids/story_ids/task_ids are all EMPTY arrays.

package/skills/{reconcile-origin → j-reconcile-origin}/SKILL.md

@@ -1,19 +1,26 @@
 ---
-name: reconcile-origin
-description: Sync the current (or specified) branch with origin by rebasing local commits on top of the latest upstream state.
+name: j.reconcile-origin
+description: Polyfill alias of the reconcile-origin skill under a collision-safe directory name. Identical behavior to /reconcile-origin — Sync the current (or specified) branch with origin by rebasing local commits on top of the latest upstream state. Use when the bare /reconcile-origin form is shadowed by another tool's own built-in command of the same name.
 keywords:
   - "sync branch"
   - "rebase origin"
   - "reconcile origin"
   - "pull rebase"
+  - j-reconcile-origin
+  - polyfill
 examples:
   - "sync my branch with origin"
   - "rebase local commits on top of origin"
   - "reconcile-origin feature/my-branch"
+  - "j-reconcile-origin"
 ---
 
 # Reconcile Origin
 
+This skill is a literal-directory-name duplicate of `skills/reconcile-origin/`. It exists so that `/j-reconcile-origin` (and `j.j-reconcile-origin`) give a guaranteed-unshadowed way to reach the same flow as `/reconcile-origin`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/reconcile-origin` 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 reconcile-origin` from `skills/reconcile-origin/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 Use this skill to rebase local work on top of the latest `origin/<branch>` state without re-implementing git logic inline.
 
 ## Instructions
@@ -22,7 +29,7 @@ Use this skill to rebase local work on top of the latest `origin/<branch>` state
    - If the user passed an argument, use that branch name.
    - Otherwise, use the current branch name.
 
-2. Invoke `.agents/skills/reconcile-origin/scripts/reconcile-origin.sh [<branch>]` and capture stdout.
+2. Invoke `.agents/skills/j-reconcile-origin/scripts/reconcile-origin.sh [<branch>]` and capture stdout.
    - Do not run any inline git commands in this skill — all git work is handled by the script.
    - The script handles dirty-worktree detection internally and returns `{"status":"error","code":"uncommitted_changes",...}` if the working tree is not clean.
 
@@ -38,7 +45,7 @@ Use this skill to rebase local work on top of the latest `origin/<branch>` state
        2. Cancel and inspect the branch setup manually
        3. Other (describe below)
 
-     - If the user chooses option 1, invoke `.agents/skills/reconcile-origin/scripts/reconcile-origin.sh <branch> --create-tracking`.
+     - If the user chooses option 1, invoke `.agents/skills/j-reconcile-origin/scripts/reconcile-origin.sh <branch> --create-tracking`.
      - If `remote_exists` is `false`, explain that neither a local branch nor `origin/<branch>` was found and stop.
    - `conflict`
      - Present one structured conflict rapport per item in `conflicts`.
@@ -55,7 +62,7 @@ Use this skill to rebase local work on top of the latest `origin/<branch>` state
        3. Handle it later — leave annotated conflict markers in the file and continue the scripted flow
        4. Other (describe below)
 
-     - If the user chooses “Handle it later”, invoke `.agents/skills/reconcile-origin/scripts/reconcile-origin.sh <branch> --handle-later <file>` for the selected conflict file.
+     - If the user chooses “Handle it later”, invoke `.agents/skills/j-reconcile-origin/scripts/reconcile-origin.sh <branch> --handle-later <file>` for the selected conflict file.
    - `handled_later`
      - Confirm that the selected file was annotated for later resolution.
      - Tell the user the conflict markers were intentionally preserved with a `# RECONCILE-ORIGIN CONFLICT:` note.
@@ -71,5 +78,5 @@ Use this skill to rebase local work on top of the latest `origin/<branch>` state
 
 ## Guard Rails
 
-- All git work must go through `.agents/skills/reconcile-origin/scripts/reconcile-origin.sh`.
+- All git work must go through `.agents/skills/j-reconcile-origin/scripts/reconcile-origin.sh`.
 - Do not inline fetch, checkout, pull, merge, rebase, or status commands in this skill body.

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

@@ -1,21 +1,28 @@
 ---
-name: redo
-description: Redo parts or entire previous implementations identified by a commit SHA or an Epic/Story number (e.g. E01, E02_S03). Expects an identifier and a description of what to redo and why. Use when the user wants to revisit, rework, or rewrite previously completed work, including updating all affected documentation.
+name: j.redo
+description: Polyfill alias of the redo skill under a collision-safe directory name. Identical behavior to /redo — Redo parts or entire previous implementations identified by a commit SHA or an Epic/Story number (e.g. E01, E02_S03). Expects an identifier and a description of what to redo and why. Use when the user wants to revisit, rework, or rewrite previously completed work, including updating all affected documentation. Use when the bare /redo form is shadowed by another tool's own built-in command of the same name.
 keywords:
   - redo
   - rework
   - rewrite
   - revisit
   - redo task
+  - j-redo
+  - polyfill
 examples:
   - "redo the login implementation"
   - "rewrite story E02_S01"
+  - "j-redo"
 metadata: 
   prefered_agent: scrum-master
 ---
 
 # Redo — Rework a Previous Implementation
 
+This skill is a literal-directory-name duplicate of `skills/redo/`. It exists so that `/j-redo` (and `j.j-redo`) give a guaranteed-unshadowed way to reach the same flow as `/redo`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/redo` 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 redo` from `skills/redo/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 ## Input Format
 
 ```

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

@@ -1,10 +1,17 @@
 ---
-name: skillify
-description: Refactor one or more existing skills into a cleaner, more maintainable structure — extracting hardcoded content into asset files, offloading deterministic steps into scripts, and reorganizing the skill body to reflect the leaner result. Use this whenever the user wants to clean up, improve, or restructure an existing skill, mentions that a skill has hardcoded content that could be templated, or asks to "skillify", "refactor", or "tidy up" a skill. Trigger even if the user just pastes a skill and says something like "can we make this better?".
+name: j.skillify
+description: Polyfill alias of the skillify skill under a collision-safe directory name. Identical behavior to /skillify — Refactor one or more existing skills into a cleaner, more maintainable structure — extracting hardcoded content into asset files, offloading deterministic steps into scripts, and reorganizing the skill body to reflect the leaner result. Use this whenever the user wants to clean up, improve, or restructure an existing skill, mentions that a skill has hardcoded content that could be templated, or asks to "skillify", "refactor", or "tidy up" a skill. Trigger even if the user just pastes a skill and says something like "can we make this better?". Use when the bare /skillify form is shadowed by another tool's own built-in command of the same name.
+keywords:
+  - j-skillify
+  - polyfill
 ---
 
 # Skillify — Refactor a Skill into a Cleaner Structure
 
+This skill is a literal-directory-name duplicate of `skills/skillify/`. It exists so that `/j-skillify` (and `j.j-skillify`) give a guaranteed-unshadowed way to reach the same flow as `/skillify`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/skillify` 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 skillify` from `skills/skillify/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 ## What this skill does
 
 Takes one or more existing skills and refactors them by:
@@ -65,4 +72,4 @@ The rewritten SKILL.md should:
 - `assets/init-old/SKILL.md` — The init skill before refactoring (hardcoded heredocs, inline JSON, hardcoded directory list)
 - `assets/init-new/SKILL.md` — The init skill after refactoring (all content in assets, steps delegated to `init.sh`)
 
-Read these when you need a concrete example of the before/after pattern.
+Read these when you need a concrete example of the before/after pattern.

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

@@ -1,21 +1,28 @@
 ---
-name: spinoff
-description: Capture a diverging topic mid-conversation. Collects context and a mandatory origin, optionally runs /brainstorm for prerequisites, saves an /idea entry, and returns focus to the primary thread.
+name: j.spinoff
+description: Polyfill alias of the spinoff skill under a collision-safe directory name. Identical behavior to /spinoff — Capture a diverging topic mid-conversation. Collects context and a mandatory origin, optionally runs /brainstorm for prerequisites, saves an /idea entry, and returns focus to the primary thread. Use when the bare /spinoff form is shadowed by another tool's own built-in command of the same name.
 keywords:
   - spinoff
   - diverge
   - side topic
   - capture topic
   - new thread
+  - j-spinoff
+  - polyfill
 examples:
   - "let's spinoff this idea"
   - "capture this as a separate thread"
+  - "j-spinoff"
 metadata:
   prefered_agent: scrum-master
 ---
 
 # Spinoff — Capture a Diverging Topic
 
+This skill is a literal-directory-name duplicate of `skills/spinoff/`. It exists so that `/j-spinoff` (and `j.j-spinoff`) give a guaranteed-unshadowed way to reach the same flow as `/spinoff`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/spinoff` 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 spinoff` from `skills/spinoff/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 ## Instructions
 
 1. **Identify the diverging topic** — Ask the user to confirm or briefly describe the diverging topic.

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

@@ -1,19 +1,26 @@
 ---
-name: status
-description: Print a human-readable summary of the entire scrum board — all epics, stories, and tasks with their statuses — plus any open rapports and unprocessed queue triggers. Use when you want a quick overview of project state without reading raw files.
+name: j.status
+description: Polyfill alias of the status skill under a collision-safe directory name. Identical behavior to /status — Print a human-readable summary of the entire scrum board — all epics, stories, and tasks with their statuses — plus any open rapports and unprocessed queue triggers. Use when you want a quick overview of project state without reading raw files. Use when the bare /status form is shadowed by another tool's own built-in command of the same name.
 keywords:
   - status
   - board summary
   - overview
   - project state
   - what's done
+  - j-status
+  - polyfill
 examples:
   - "show me the project status"
   - "what's the state of the board?"
+  - "j-status"
 ---
 
 # Status — Board Overview
 
+This skill is a literal-directory-name duplicate of `skills/status/`. It exists so that `/j-status` (and `j.j-status`) give a guaranteed-unshadowed way to reach the same flow as `/status`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/status` 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 status` from `skills/status/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
 ## Instructions
 
 1. **Read `project/configs/workflow.json`** to confirm board paths. Fall back to `project/board/` if the file does not exist.

package/skills/j-todo/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: j.todo
+description: Polyfill alias of the todo skill under a collision-safe directory name. Identical behavior to /todo — Add missions to the project todo list (project/todo.md), optionally linking them to epics and stories. Loops until the user is done, then optionally executes the list. Use when the bare /todo form is shadowed by another tool's own built-in command of the same name.
+keywords:
+  - todo
+  - add task
+  - queue work
+  - backlog
+  - add to list
+  - j-todo
+  - polyfill
+examples:
+  - "add this to the todo list"
+  - "queue this as a task"
+  - "j-todo"
+metadata: 
+  prefered_agent: scrum-master
+---
+
+# Todo — Add Missions to the Todo List
+
+This skill is a literal-directory-name duplicate of `skills/todo/`. It exists so that `/j-todo` (and `j.j-todo`) give a guaranteed-unshadowed way to reach the same flow as `/todo`, even if a host tool's own built-in command of the same name would otherwise shadow or override the bare `/todo` 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 todo` from `skills/todo/SKILL.md` — do not hand-edit it; re-run the generator instead to pick up source changes.
+
+## `--trivial` Flag
+
+**Syntax:** `/todo --trivial <description>` — optionally combined with the same `: <Epic no.>_<Story no.>` linkage syntax normal `/todo` entries use, e.g. `/todo --trivial Fix typo in error message: E12_S03`.
+
+When `--trivial` is present, the mission is written as a **fully-formed task board file immediately** (not just a raw `todo.md` line deferred to `/do`'s own breakdown pass) with `execution_scope: inline` forced unconditionally — no threshold computation is consulted for the scope value itself. See step 4.5 below for the mechanics.
+
+**Human-only override.** `--trivial` is invoked by a human typing `/todo --trivial ...` — it is never applied by the scrum-master to itself during autonomous story/epic breakdown elsewhere (e.g. `/jenga`'s Phase 0.5, or `/do`'s own scrum-master decomposition step in `skills/do/SKILL.md` step 3). Those paths keep using the normal heuristic-only `execution_scope` assignment documented in `agents/scrum-master.md`'s Execution Scope Assignment section, unmodified by this flag.
+
+**Fallback on failure is out of scope here.** If a `--trivial`-forced inline run fails the smoke-harness or shows scope creep at dispatch time, `/do`'s own `--trivial` handling (a separate task, E32_S14_T02) is responsible for falling back to the full `task` pipeline — this skill only ever writes the initial forced-inline task.
+
+## Instructions
+
+1. **Ensure `project/todo.md` exists** — If it doesn't exist, it will be auto-created by `todo_manager.sh` — no manual action needed.
+
+2. **Ask the user about the mission:**
+   - Where do you want to do this?
+   - What would you like to do?
+   - What is the goal?
+   - (If `--trivial` was passed, these answers still apply — `--trivial` changes how the mission is written to the board in step 4.5, not what's asked here.)
+
+3. **Classify the mission** — Check if it fits into:
+   - An existing story
+   - A new story inside an existing Epic
+   - A new story inside a new Epic
+   - None of the above
+
+   **`--trivial` requires an existing (or, in this same step, newly-created) story to attach to.** It forces the scope of a single task, not a container — if the mission has no story yet, create it now via step 4 below exactly as normal, then continue to step 4.5. `--trivial` cannot be used for "None of the above."
+
+4. **Update project documentation** — Add the mission to the appropriate files under `project/board/epics/` and `project/board/stories/` if applicable.
+   - If the mission involves implementing or modifying a skill, apply the **Skill Implementation Principle — Scripts Over Inline Logic** (see `CLAUDE.md` / `AGENTS.md`): note in the story/task's acceptance criteria that deterministic, repeatable steps must be offloaded to scripts under `skills/<name>/scripts/` (or `scripts/`) rather than encoded as inline agent instructions in `SKILL.md`.
+   - If the user indicates the mission is high-risk, or explicitly asks to flag it, set an elevated caution tier directly on the story or task frontmatter: `crucial_level` (one of `advisory`, `gated`, `locked` — see `templates/SCRUM_BOARD_SCHEMA.md` for valid values and their meaning), `crucial_set_by: user`, and `crucial_note` capturing the user's stated reason. This user-initiated flag is written immediately — it does not require the confirm-before-write gate, which applies only to scrum-master-*proposed* caution tiers (a separate, heuristic-driven path).
+
+4.5. **If `--trivial` was passed, create the task now** (skip step 5 — this step writes the todo.md entry itself):
+
+   a. **Estimate the change**, using the same judgment `agents/scrum-master.md`'s Execution Scope Assignment heuristic applies: how many files will this mission likely touch, and roughly how many lines. This is a reasoning step, not a script step — do not guess wildly, but a rough, honest estimate is sufficient.
+
+   b. **Determine `computed_tier`** — what `execution_scope` the normal heuristic would have assigned to this estimate, purely for the audit trail (it is never written as the actual `execution_scope`, which is always forced to `inline`):
+      - Read `inline_max_files`, `inline_max_lines`, and `story_max_files` from `project/configs/scope-thresholds.json` at run time — never hardcode these numbers here.
+      - Apply `agents/scrum-master.md`'s `inline` / `story` / `task` heuristics (file count vs. `inline_max_files`, line estimate vs. `inline_max_lines`, contention and cross-cutting checks for `story`) to the estimate from (a). The result is `computed_tier` — one of `inline`, `task`, or `story` (never `epic` — the heuristic never autonomously computes `epic`).
+
+   c. **Run the helper script**, which handles everything mechanical — next task-ID assignment, writing the task board file with `execution_scope: inline` forced, registering the new task ID into the parent story's `tasks:` frontmatter list, and adding the `project/todo.md` entry using the full task ID (so `/do` routes straight into its Inline Execution Path with no redundant breakdown pass):
+      ```
+      bash skills/j-todo/scripts/add_trivial_task.sh \
+        --story <E##_S##> \
+        --title "<mission title>" \
+        --description "<mission description>" \
+        --criteria "<criterion 1>|<criterion 2>|..." \
+        --computed-tier <inline|task|story> \
+        --est-files <N> \
+        --est-lines <M> \
+        [--prerequisites "<text>"]
+      ```
+      The script writes `scope_rationale` in the form `"forced inline via --trivial; computed scope would have been '<computed_tier>' — estimated <N> files, ~<M> lines"` and sets `jenga_assigned: false` with a matching `override_justification`, so `/do` step 4.1's existing override-validation logs the override on dispatch — no separate acknowledgement step needed here.
+      On success the script prints the new task ID to stdout; on failure (e.g. the story doesn't exist yet, or `--computed-tier` is invalid) it exits non-zero with an explanatory message on stderr — surface that to the user rather than retrying blindly.
+   d. Continue to step 6 (skip step 5 — the script already added the `todo.md` entry).
+
+5. **Add to `project/todo.md`** by running (skip this step if step 4.5 already ran):
+   ```
+   bash scripts/todo_manager.sh add '<mission title>: <Epic no.>_<Story no.>'
+   ```
+   The epic and story reference is only required if the mission is assigned to one.
+
+6. **Ask the user**: "Add another todo" or "Done"?
+   - If **add another** — go back to step 2. (`--trivial` applies only to the mission it was passed with — it does not carry over to the next mission unless the user says `--trivial` again.)
+   - If **done** — ask if they want to execute the todo list.
+     - If **yes** — invoke the `/do` skill.
+     - If **no** — exit.

package/skills/{todo → j-todo}/assets/todo_handoff_template.md

@@ -13,7 +13,7 @@
 <!-- PLACEHOLDER: what this todo is trying to achieve -->
 
 ## Affected Files or Scope
-<!-- PLACEHOLDER: which files, modules, or areas are involved, e.g. src/auth/, skills/todo/ -->
+<!-- PLACEHOLDER: which files, modules, or areas are involved, e.g. src/auth/, skills/j-todo/ -->
 
 ## Intended Approach
 <!-- PLACEHOLDER: step-by-step or high-level approach to the work -->

package/skills/j-todo/scripts/add_trivial_task.sh

@@ -0,0 +1,216 @@
+#!/usr/bin/env bash
+# skills/j-todo/scripts/add_trivial_task.sh
+#
+# Creates a fully-formed task board file for a `/todo --trivial` mission,
+# forced to execution_scope: inline unconditionally, and registers it both
+# in its parent story's tasks: frontmatter list and in project/todo.md.
+#
+# This script performs only the MECHANICAL half of --trivial: templating the
+# task file, assigning the next task number, and wiring it into the board.
+# The JUDGMENT half — estimating file/line counts and deciding what
+# execution_scope the normal heuristic in agents/scrum-master.md would have
+# assigned (computed_tier) — happens in the calling agent's instructions
+# (skills/j-todo/SKILL.md), per the Skill Implementation Principle: a step that
+# requires reasoning about branching logic, new dependencies, etc. does not
+# belong in a script. This script never reads project/configs/scope-thresholds.json
+# or recomputes computed_tier itself — it only records what it was told.
+#
+# Usage:
+#   add_trivial_task.sh --story <E##_S##> --title "<title>" \
+#     --description "<description>" --criteria "<c1>|<c2>|..." \
+#     --computed-tier <inline|task|story> --est-files <N> --est-lines <M> \
+#     [--prerequisites "<text>"]
+#
+# Requires an ALREADY-EXISTING parent story file (--trivial does not create
+# stories or epics — resolve/create those first via the normal /todo flow).
+#
+# On success, prints the new task ID (e.g. E32_S14_T05) to stdout and exits 0.
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+cd "$REPO_ROOT"
+
+TASKS_DIR="project/board/tasks"
+STORIES_DIR="project/board/stories"
+UPDATE_STORY_SCRIPT="skills/j-todo/scripts/update_story_tasks.py"
+
+story_id=""
+title=""
+description=""
+criteria=""
+computed_tier=""
+est_files=""
+est_lines=""
+prerequisites="None."
+
+usage() {
+  cat >&2 <<EOF
+Usage: $0 --story <E##_S##> --title "<title>" --description "<description>" \\
+       --criteria "<c1>|<c2>|..." --computed-tier <inline|task|story> \\
+       --est-files <N> --est-lines <M> [--prerequisites "<text>"]
+EOF
+  exit 1
+}
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --story) story_id="$2"; shift 2 ;;
+    --title) title="$2"; shift 2 ;;
+    --description) description="$2"; shift 2 ;;
+    --criteria) criteria="$2"; shift 2 ;;
+    --computed-tier) computed_tier="$2"; shift 2 ;;
+    --est-files) est_files="$2"; shift 2 ;;
+    --est-lines) est_lines="$2"; shift 2 ;;
+    --prerequisites) prerequisites="$2"; shift 2 ;;
+    -h|--help) usage ;;
+    *) echo "Error: unknown argument '$1'" >&2; usage ;;
+  esac
+done
+
+for req_name in story_id title description criteria computed_tier est_files est_lines; do
+  if [ -z "${!req_name}" ]; then
+    echo "Error: --${req_name//_/-} is required" >&2
+    exit 1
+  fi
+done
+
+if ! [[ "$story_id" =~ ^E[0-9]+_S[0-9]+$ ]]; then
+  echo "Error: --story must look like E##_S## (got '$story_id')" >&2
+  exit 1
+fi
+
+case "$computed_tier" in
+  inline|task|story) ;;
+  *) echo "Error: --computed-tier must be one of: inline, task, story (got '$computed_tier')" >&2; exit 1 ;;
+esac
+
+case "$est_files" in
+  ''|*[!0-9]*) echo "Error: --est-files must be a non-negative integer (got '$est_files')" >&2; exit 1 ;;
+esac
+case "$est_lines" in
+  ''|*[!0-9]*) echo "Error: --est-lines must be a non-negative integer (got '$est_lines')" >&2; exit 1 ;;
+esac
+
+epic_id="${story_id%%_S*}"
+
+# Locate the parent story file. --trivial requires it to already exist.
+story_file=""
+for f in "${STORIES_DIR}/${story_id}_"*.md; do
+  if [ -f "$f" ]; then
+    story_file="$f"
+    break
+  fi
+done
+if [ -z "$story_file" ]; then
+  echo "Error: no story file found for $story_id under $STORIES_DIR/. --trivial requires an already-resolved story — create it via the normal /todo flow first." >&2
+  exit 1
+fi
+
+if [ ! -f "$UPDATE_STORY_SCRIPT" ]; then
+  echo "Error: $UPDATE_STORY_SCRIPT not found." >&2
+  exit 1
+fi
+
+# Determine the next task number for this story by scanning existing task files.
+max_num=0
+shopt -s nullglob
+for f in "${TASKS_DIR}/${story_id}_T"*.md; do
+  base="$(basename "$f")"
+  num="$(printf '%s' "$base" | sed -nE "s/^${story_id}_T([0-9]+)_.*/\1/p")"
+  if [ -n "$num" ]; then
+    num=$((10#$num))
+    if [ "$num" -gt "$max_num" ]; then
+      max_num=$num
+    fi
+  fi
+done
+shopt -u nullglob
+next_num=$((max_num + 1))
+next_num_padded="$(printf '%02d' "$next_num")"
+task_id="${story_id}_T${next_num_padded}"
+
+shopt -s nullglob
+existing_matches=("${TASKS_DIR}/${task_id}_"*.md)
+shopt -u nullglob
+if [ "${#existing_matches[@]}" -gt 0 ]; then
+  echo "Error: a task file for $task_id already exists (ID collision). Aborting." >&2
+  exit 1
+fi
+
+# Slugify the title for the filename.
+slug="$(printf '%s' "$title" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+//; s/-+$//')"
+slug="${slug:0:60}"
+slug="${slug%-}"
+if [ -z "$slug" ]; then
+  slug="trivial-task"
+fi
+
+today="$(date -u +%Y-%m-%d)"
+
+scope_rationale="forced inline via --trivial; computed scope would have been '${computed_tier}' — estimated ${est_files} files, ~${est_lines} lines"
+override_justification="/todo --trivial invoked by user on ${today}; execution_scope forced to 'inline', overriding the heuristic's computed '${computed_tier}' tier (see scope_rationale)."
+
+# Build the Acceptance Criteria block from the pipe-separated --criteria value.
+criteria_block=""
+IFS='|' read -ra crit_arr <<< "$criteria"
+for c in "${crit_arr[@]}"; do
+  c_trimmed="$(printf '%s' "$c" | sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//')"
+  if [ -n "$c_trimmed" ]; then
+    criteria_block+="- [ ] ${c_trimmed}"$'\n'
+  fi
+done
+if [ -z "$criteria_block" ]; then
+  echo "Error: --criteria produced no usable acceptance criteria" >&2
+  exit 1
+fi
+
+task_file="${TASKS_DIR}/${task_id}_${slug}.md"
+
+cat > "$task_file" <<EOF
+---
+id: ${task_id}
+story_id: ${story_id}
+epic_id: ${epic_id}
+title: ${title}
+status: Pending
+date_created: ${today}
+date_started:
+date_completed:
+dates_previously_completed:
+reopened_on:
+reopened_reason:
+assigned_to: developer
+docs: []
+execution_scope: inline
+needs_docs: false
+scope_rationale: "${scope_rationale}"
+jenga_assigned: false
+override_justification: "${override_justification}"
+---
+
+# Task: ${title}
+
+## Description
+${description}
+
+## Prerequisites
+${prerequisites}
+
+## Acceptance Criteria
+${criteria_block}
+EOF
+
+echo "Wrote task file: ${task_file}"
+
+# Register the new task under its parent story's tasks: frontmatter list.
+if ! scripts/with-lock.sh "$story_file" -- python3 "$UPDATE_STORY_SCRIPT" "$story_file" "$task_id"; then
+  echo "Error: failed to register ${task_id} in ${story_file}'s tasks: list (lock timeout or write failure)." >&2
+  exit 1
+fi
+
+# Register the todo entry using the FULL task ID, so /do routes straight into
+# its Inline Execution Path without a redundant breakdown pass.
+bash scripts/todo_manager.sh add "${title}: ${task_id}"
+
+echo "${task_id}"