@jenga-ai/agent 1.2.3 → 1.3.0

package/README.md

@@ -25,11 +25,13 @@ npm install @jenga-ai/agent
 | Agent | Skills & Agents | Root Context File |
 |---|---|---|
 | **Claude Code** | `.claude/` — mirrored automatically on install | `CLAUDE.md` — generated by `/init` today |
-| **GitHub Copilot** | `.agents/` — mirrored automatically on install | `.github/copilot-instructions.md` — generated by `/init` today |
+| **GitHub Copilot** | `.agents/` — mirrored automatically on install | `.github/copilot-instructions.md` — bootstrapped at `npm install` time, refined by `jenga init` |
 | **Codex** | `.agents/` — mirrored automatically on install | `AGENTS.md` — generated by `/init` today |
 
 `CLAUDE.md` and `AGENTS.md` are generated unconditionally by `/init` — every agent gets a real, populated root-level context file out of the box, not just a pointer. If either file already exists as a genuine pre-existing user file, Jenga writes its own copy as `J-CLAUDE.md` / `J-AGENTS.md` instead and inserts a short reference into the existing file, leaving it otherwise untouched.
 
+`.github/copilot-instructions.md` follows a different path: `scripts/postinstall.js` writes it unconditionally and non-interactively the moment `npm install` finishes, so Copilot has working `/skill-name` routing instructions even if a consumer's very first action is a Copilot slash command, before the separate `jenga init` CLI wizard has ever run. Running `jenga init` afterward refines the same file using the user's actual chosen skills path — it is never generated by the `/init` skill itself.
+
 ---
 
 ## The Problem It Solves
@@ -226,6 +228,7 @@ Skills live in `.agents/skills/<name>/SKILL.md`. Invoke with `/<name>` in your A
 | `/do` | Execute tasks from the scrum board, drives the Developer agent through the full loop |
 | `/dooo` | Parallel execution orchestrator — runs multiple tasks simultaneously via sub-agents |
 | `/redo` | Rework a previous implementation by commit SHA or Epic/Story number |
+| `/publish` | Configure, validate, and orchestrate scaffolded release workflows — `setup`, `deploy`, `stage` (npm/npm-ci pre-approval staged publishing), `history`, `release-notes` |
 | `/error` | Guided troubleshooting — gathers context, investigates, and drives a fix |
 | `/train` | Scaffold and run ML training jobs (new job from template or run existing) |
 

package/agents/developer.md

@@ -287,6 +287,24 @@ See `templates/PROBLEM_RAPPORT_TEMPLATE.md` for the required format. Commit the
 
 ---
 
+## Investigative Mode
+
+**Trigger.** You are sometimes dispatched not to implement a task, but purely to build understanding of existing code — e.g. by the scrum-master during `/uncharted`'s conversational architecture elicitation, when it needs to know what a named flow or target actually does before proposing graph nodes or asking the user to confirm/correct an understanding. This is a distinct dispatch mode from the standard Task Intake flow above, and it is recognized by the request itself (you are asked to *trace* or *investigate*, not to *implement*), not by any board field.
+
+**Hard constraints.** Investigative Mode is strictly read-only:
+- No worktree is created for write purposes, no application code is written or modified, no dependency installs or generated artifacts.
+- No commits of any kind.
+- No board status writes — task/story/epic status is the tester's exclusive responsibility, and Investigative Mode doesn't touch the board at all, not even a status you'd normally be permitted to leave alone.
+- No edits to `PROJECT_SUMMARY.md`, board files, or any other project artifact. The only output is the trace itself, returned to whoever dispatched you.
+
+**Sandbox — reuse the existing worktree hooks, read-only.** Per the story decision behind this mode (see `project/documentation/plans/uncharted-interactive-elicitation.md` and its solution assessment, Problem 7 / Solution A), do not invent a new isolation mechanism. Mount a throwaway worktree via the same `WorktreeCreate` hook used for normal tasks (see Worktree Management above) purely to get a disposable, isolated checkout to read from, and tear it down via `WorktreeRemove` once the investigation ends. This is convention-enforced, not filesystem-enforced: the hook mounts an ordinary writable worktree, and it is Investigative Mode's contract — not a permission bit — that keeps it read-only. Treat any temptation to write into that worktree (a scratch file, a quick local test run) as a violation of the mode, not a harmless side effect.
+
+**What you trace.** For the named flow or target, follow what the code actually does: call paths, data flow, key decision points, error handling, and any conditions or configuration that change the behavior. Report this in plain language back to the dispatcher — this is not a new artifact type and is not written to disk as part of Investigative Mode itself; if the dispatching flow later decides the finding is worth persisting, that happens through its own normal mechanism (e.g. a graph write or a summary doc), not through you.
+
+**Human-oracle-availability limitation.** For genuinely undocumented code, there is often no reliable code-level way to confirm what was *intended* — only what currently happens. Naming conventions can mislead, a branch that looks dead may be load-bearing for a caller you haven't found, and "this must be for X" is a guess dressed as a finding. When you hit this wall, say so explicitly — report the uncertainty, name what you did and didn't check, and stop short of presenting a guess as a settled fact. This is an accepted, standing limitation of the mode, not something to engineer around by fabricating confidence.
+
+---
+
 ## Hooks
 
 Defined in agent frontmatter:

package/agents/scrum-master.md

@@ -76,6 +76,7 @@ This is a self-contained procedure, not a session-start-only step. It may be inv
        6. **This is the only path** by which a mid-task agent request results in a `crucial_level` board write. Developer and tester never write `crucial_level`, `crucial_set_by`, or `crucial_note` directly to a board file themselves under any circumstance — they may only *request* the change via a `crucial_escalation` rapport, and the actual frontmatter write happens here, exclusively by scrum-master, closing the loop described in E39's Purpose section ("the actual frontmatter write still goes through scrum-master, never the subagent itself").
    - `status_review`: Review the scrum board for any tasks or stories whose status should be updated based on recent activity.
    - `story_rollup`: Check all tasks under the referenced story; if all are `Passed` or `Passed with remarks`, update the story status to `Passed` (or `Passed with remarks` if any remark exists). Then check epic rollup (see Rollup Logic).
+   - `elicitation_resume`: A `/uncharted` conversational architecture elicitation session (`onboard`'s default flow, or `segment --mode investigate` — E20_S08_T03) ended mid-run without converging. Read `state_file` (`project/queue/elicitation-state/<elicitation_id>.json`, written by `skills/uncharted/scripts/elicitation-state.sh`) to see exactly where it left off — which nodes already converged, which are still pending or flagged, and any directory-triage/checkpoint data already confirmed — then resume the conversational flow documented in `skills/uncharted/SKILL.md`'s Multi-Session Persistence subsection from that point rather than restarting the elicitation from scratch. If the state file is missing or unreadable, report that to the user rather than silently starting a fresh elicitation under the same id.
    - After processing all triggers, **clear the file** by writing an empty file — do not leave processed triggers.
 
 2. **Check `project/queue/project_summary_updates.jsonl`** — If non-empty, review each proposed update and apply, revise, or reject it with a short note. Clear the file after processing.

package/agents/tester.md

@@ -407,6 +407,24 @@ There is no default analytics run. Analytics only happen when explicitly scoped
 
 ---
 
+## Investigative Mode
+
+**Trigger.** You are sometimes dispatched not to validate a task's implementation, but purely to build understanding of what the existing test suite actually covers for a named flow or target — e.g. by the scrum-master during `/uncharted`'s conversational architecture elicitation, alongside the developer's Investigative Mode pass over the same flow. This is a distinct dispatch mode from the standard Sender Object / Task Intake / Status Management flow above, recognized by the request itself (you are asked to *trace coverage*, not to *validate a task*), not by any board field.
+
+**Hard constraints.** Investigative Mode is strictly read-only:
+- No worktree is created for write purposes, no test files are written or modified, no test runs that mutate state, no dependency installs.
+- No commits of any kind.
+- No board status writes — this mode doesn't touch task/story/epic status at all, even though status writes are ordinarily your exclusive responsibility.
+- No edits to `PROJECT_SUMMARY.md`, board files, or any other project artifact. The only output is the trace itself, returned to whoever dispatched you.
+
+**Sandbox — reuse the existing worktree hooks, read-only.** Per the story decision behind this mode (see `project/documentation/plans/uncharted-interactive-elicitation.md` and its solution assessment, Problem 7 / Solution A), do not invent a new isolation mechanism. Mount a throwaway worktree via the same `WorktreeCreate` hook the developer agent uses for normal tasks, purely to get a disposable, isolated checkout to read from, and tear it down via `WorktreeRemove` once the investigation ends. This is convention-enforced, not filesystem-enforced: the hook mounts an ordinary writable worktree, and it is Investigative Mode's contract — not a permission bit — that keeps it read-only. Do not execute the test suite in a way that writes fixtures, snapshots, or coverage artifacts back into that worktree; reading existing test files and existing coverage output (if already present) is the mode's ceiling.
+
+**What you trace — the distinct vantage point.** Where the developer's Investigative Mode pass traces what the code *does*, yours traces what the test suite *actually exercises and verifies* for that same flow: which tests touch it, what they assert (and what they merely execute without asserting), and where the coverage gap is — untested branches, unasserted side effects, error paths with no test at all, or a flow that "passes" only because nothing checks the part that matters. These are two distinct vantage points on the same flow, not two names for the same read; do not simply restate the developer's trace with "and there's a test for it" appended.
+
+**Human-oracle-availability limitation.** The same limitation the developer faces applies to you, with an added facet: a passing test suite doesn't clarify intent either — a test can be green because it correctly verifies the right behavior, or green because it asserts nothing meaningful, and the test's own docstring or name can be as misleading as the code's. When you cannot determine from the tests (or their absence) what the intended behavior actually is, say so explicitly — report the uncertainty and the specific gap you couldn't close, rather than presenting a guess as a settled coverage verdict. This is an accepted, standing limitation of the mode, not something to engineer around by fabricating confidence.
+
+---
+
 ## Hooks
 
 Defined in agent frontmatter:

package/hooks/on_session_end.sh

@@ -308,6 +308,33 @@ for HANDOFF_FILE in "$HANDOFF_DIR"/*.json; do
         echo "$TRIGGER" >> "$DEV_QUEUE"
         echo "[on_session_end] scrum-master → developer queue: implementation_assignment"
       fi
+
+      # A conversational architecture elicitation session (/uncharted
+      # onboard's default flow, or segment --mode investigate — E20_S08_T03)
+      # ended mid-run without converging. The session driving it is
+      # responsible for calling skills/uncharted/scripts/elicitation-state.sh
+      # pause and then writing this handoff with status "elicitation_paused"
+      # as its last action (see skills/uncharted/SKILL.md's Multi-Session
+      # Persistence subsection). This routes that pause into a resume
+      # signal for the next scrum-master session, per the existing
+      # SessionEnd/queue pattern rather than a new persistence mechanism
+      # (solution-assessment-uncharted-interactive-elicitation.md, Problem 11).
+      if [ "$HANDOFF_STATUS" = "elicitation_paused" ]; then
+        TRIGGER=$(jq -n \
+          --slurpfile h "$HANDOFF_FILE" \
+          --arg type "elicitation_resume" \
+          --arg date "$TIMESTAMP" \
+          '{
+            type: $type,
+            date: $date,
+            sender: { agent: "scrum-master", session_id: $h[0].session_id, date: $date },
+            elicitation_id: ($h[0].elicitation_id // ""),
+            state_file:     ($h[0].state_file     // ""),
+            message: "A conversational architecture elicitation session paused mid-run. Resume it from the persisted state file."
+          }')
+        echo "$TRIGGER" >> "$QUEUE_FILE"
+        echo "[on_session_end] scrum-master (elicitation_paused) → scrum-master queue: elicitation_resume"
+      fi
       ;;
 
     developer)

package/lib/commands/init.js

@@ -1,10 +1,11 @@
 import { createInterface } from "readline";
-import { readFileSync, writeFileSync, existsSync, appendFileSync, mkdirSync, readdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, appendFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { validateConfig } from "../config-schema.js";
 import { injectSettings } from "../inject-settings.js";
 import { generateAgentContext } from "../generate-agent-context.js";
+import { generateCopilotInstructions } from "../generate-copilot-instructions.js";
 
 const CONFIG_FILE = "jenga.cli.json";
 
@@ -125,74 +126,28 @@ export async function runInit(args, projectRoot = process.cwd()) {
       console.warn("You can register it manually later by running jenga init again.");
     }
 
-    // Generate .github/copilot-instructions.md from template.
-    // Templates ship inside the jenga-agent package (node_modules/jenga-agent/templates/).
-    // Fall back to a bare `templates/` at the project root only for the dev-repo case.
+    // Generate .github/copilot-instructions.md from template, via the shared generator
+    // (lib/generate-copilot-instructions.js) also used unconditionally by scripts/postinstall.js
+    // at install time (E46_S03_T01). Templates ship inside the jenga-agent package
+    // (node_modules/jenga-agent/templates/), with a bare `templates/` at the project root as a
+    // fallback for the dev-repo case — both handled inside the shared generator.
+    //
+    // skillsPath may be a string or an array (multi-target installs); pick the first existing
+    // directory — mirrored copies hold identical content. This pass uses the user's actual
+    // chosen skillsPath from the wizard, which may differ from postinstall's `.agents/skills`
+    // default and refines whatever postinstall already bootstrapped. The shared generator's
+    // idempotent marker-replace logic means running it again here never duplicates the JENGA
+    // block or corrupts content outside the markers.
     try {
-      const tplCandidates = [
-        join(PACKAGE_ROOT, "templates", "copilot-instructions.md.tpl"),
-        join(projectRoot, "templates", "copilot-instructions.md.tpl"),
-      ];
-      const tplPath = tplCandidates.find(existsSync);
-      if (tplPath) {
-        const tpl = readFileSync(tplPath, "utf8");
-
-        // Build skill list from skillsPath. skillsPath may be a string or an
-        // array (multi-target installs); pick the first existing directory —
-        // mirrored copies hold identical content.
-        const skillsPathList = Array.isArray(config.skillsPath) ? config.skillsPath : [config.skillsPath];
-        const skillsDir = skillsPathList
-          .map(p => join(projectRoot, p))
-          .find(existsSync);
-        let skillLines = [];
-        if (skillsDir) {
-          for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
-            if (!entry.isDirectory()) continue;
-            const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
-            let description = "";
-            if (existsSync(skillMdPath)) {
-              const content = readFileSync(skillMdPath, "utf8");
-              const match = content.match(/^description:\s*(.+)$/m);
-              if (match) description = match[1].trim();
-            }
-            skillLines.push(`- **${entry.name}**${description ? `: ${description}` : ""}`);
-          }
-        }
-        const skillList = skillLines.length > 0 ? skillLines.join("\n") : "_No skills found._";
-        const rendered = tpl.replace("{{SKILL_LIST}}", skillList);
-
-        const githubDir = join(projectRoot, ".github");
-        const copilotInstructionsPath = join(githubDir, "copilot-instructions.md");
-
-        if (!existsSync(githubDir)) mkdirSync(githubDir, { recursive: true });
-
-        if (!existsSync(copilotInstructionsPath)) {
-          writeFileSync(copilotInstructionsPath, rendered, "utf8");
-        } else {
-          // Replace only the JENGA block; preserve content outside the markers
-          const existing = readFileSync(copilotInstructionsPath, "utf8");
-          const startMarker = "<!-- JENGA:START -->";
-          const endMarker = "<!-- JENGA:END -->";
-          const startIdx = existing.indexOf(startMarker);
-          const endIdx = existing.indexOf(endMarker);
-
-          // Extract the new JENGA block from rendered template
-          const renderedStart = rendered.indexOf(startMarker);
-          const renderedEnd = rendered.indexOf(endMarker);
-          const newBlock = rendered.slice(renderedStart, renderedEnd + endMarker.length);
-
-          let updated;
-          if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
-            updated =
-              existing.slice(0, startIdx) +
-              newBlock +
-              existing.slice(endIdx + endMarker.length);
-          } else {
-            // No existing markers — append the block
-            updated = existing + (existing.endsWith("\n") ? "" : "\n") + newBlock + "\n";
-          }
-          writeFileSync(copilotInstructionsPath, updated, "utf8");
-        }
+      const skillsPathList = Array.isArray(config.skillsPath) ? config.skillsPath : [config.skillsPath];
+      const skillsDir = skillsPathList
+        .map(p => join(projectRoot, p))
+        .find(existsSync);
+
+      const result = generateCopilotInstructions(projectRoot, PACKAGE_ROOT, skillsDir);
+      if (result.skipped) {
+        console.warn("Warning: templates/copilot-instructions.md.tpl not found — skipped .github/copilot-instructions.md generation.");
+      } else {
         console.log("✓ .github/copilot-instructions.md written");
       }
     } catch (e) {

package/lib/generate-copilot-instructions.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * lib/generate-copilot-instructions.js — .github/copilot-instructions.md generation
+ *
+ * Single source of truth for scaffolding the Copilot routing-instructions file from
+ * templates/copilot-instructions.md.tpl (extracted from lib/commands/init.js per E46_S03_T01).
+ * Used by:
+ *   - scripts/postinstall.js  (runs unconditionally, non-interactively, on every `npm install`)
+ *   - lib/commands/init.js    (the interactive `jenga init` CLI wizard, using the user's chosen
+ *                              skillsPath — may differ from postinstall's default)
+ *
+ * Root-cause context: `.github/copilot-instructions.md` teaches Copilot the `/skill-name` →
+ * `.agents/skills/<name>/SKILL.md` routing convention. It was previously written only by the
+ * `jenga init` CLI wizard, never by postinstall.js — so a consumer whose very first action was
+ * typing `/init` inside Copilot (before ever running `jenga init`) got no routing at all.
+ * Extracting this into a shared, parameterized function lets postinstall.js bootstrap a working
+ * routing file immediately, with `jenga init` free to refine it later using the user's actual
+ * chosen skills path.
+ *
+ * Collision behaviour (preserved verbatim from the original inline implementation — do not
+ * rewrite this algorithm, only relocate it):
+ *   - If `.github/copilot-instructions.md` does not exist, write the rendered template in full.
+ *   - If it exists, replace only the content between `<!-- JENGA:START -->` and
+ *     `<!-- JENGA:END -->`, preserving everything outside the markers.
+ *   - If it exists but has no JENGA markers, append the block to the end of the file.
+ * This makes repeat runs (postinstall run twice, or postinstall followed by `jenga init`)
+ * idempotent: the JENGA block is never duplicated and content outside the markers is never
+ * touched.
+ *
+ * ESM, Node built-ins only — mirrors lib/generate-agent-context.js and lib/mirror.js.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+// This file lives at <package>/lib/generate-copilot-instructions.js — one level up is the
+// installed jenga-agent package root, which holds templates/.
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_PACKAGE_ROOT = join(__dirname, "..");
+
+const START_MARKER = "<!-- JENGA:START -->";
+const END_MARKER = "<!-- JENGA:END -->";
+
+function resolveTemplatePath(projectRoot, packageRoot) {
+  const candidates = [
+    join(packageRoot, "templates", "copilot-instructions.md.tpl"),
+    join(projectRoot, "templates", "copilot-instructions.md.tpl"),
+  ];
+  return candidates.find(existsSync);
+}
+
+/**
+ * Build the {{SKILL_LIST}} markdown block by scanning `skillsDir` for subdirectories
+ * containing a SKILL.md, extracting each one's `description:` frontmatter line.
+ */
+function buildSkillList(skillsDir) {
+  if (!skillsDir || !existsSync(skillsDir)) return "_No skills found._";
+
+  const skillLines = [];
+  for (const entry of readdirSync(skillsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
+    let description = "";
+    if (existsSync(skillMdPath)) {
+      const content = readFileSync(skillMdPath, "utf8");
+      const match = content.match(/^description:\s*(.+)$/m);
+      if (match) description = match[1].trim();
+    }
+    skillLines.push(`- **${entry.name}**${description ? `: ${description}` : ""}`);
+  }
+  return skillLines.length > 0 ? skillLines.join("\n") : "_No skills found._";
+}
+
+/**
+ * Replace only the JENGA:START..JENGA:END block in an existing copilot-instructions.md with the
+ * freshly rendered one, preserving everything outside the markers. If no existing file, write
+ * the rendered template in full. If the existing file has no markers, append the block.
+ */
+function writeCopilotInstructions(path, rendered) {
+  if (!existsSync(path)) {
+    writeFileSync(path, rendered, "utf8");
+    return;
+  }
+
+  const existing = readFileSync(path, "utf8");
+  const startIdx = existing.indexOf(START_MARKER);
+  const endIdx = existing.indexOf(END_MARKER);
+
+  const renderedStart = rendered.indexOf(START_MARKER);
+  const renderedEnd = rendered.indexOf(END_MARKER);
+  const newBlock = rendered.slice(renderedStart, renderedEnd + END_MARKER.length);
+
+  let updated;
+  if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
+    updated = existing.slice(0, startIdx) + newBlock + existing.slice(endIdx + END_MARKER.length);
+  } else {
+    // No existing markers — append the block.
+    updated = existing + (existing.endsWith("\n") ? "" : "\n") + newBlock + "\n";
+  }
+  writeFileSync(path, updated, "utf8");
+}
+
+/**
+ * Generate (or idempotently refresh) `.github/copilot-instructions.md` at projectRoot from the
+ * shared template.
+ *
+ * @param {string} projectRoot - project root directory (default: cwd)
+ * @param {string} packageRoot - installed jenga-agent package root (default: derived from this
+ *   file's own location)
+ * @param {string} skillsDir - path to the skills directory, resolved relative to projectRoot if
+ *   not already absolute (e.g. ".agents/skills" from postinstall, or the user's chosen
+ *   skillsPath from the `jenga init` wizard)
+ * @returns {{written: boolean, path?: string, skipped?: boolean}}
+ */
+export function generateCopilotInstructions(
+  projectRoot = process.cwd(),
+  packageRoot = DEFAULT_PACKAGE_ROOT,
+  skillsDir
+) {
+  const tplPath = resolveTemplatePath(projectRoot, packageRoot);
+  if (!tplPath) {
+    return { written: false, skipped: true };
+  }
+
+  const tpl = readFileSync(tplPath, "utf8");
+
+  const resolvedSkillsDir = skillsDir
+    ? (skillsDir.startsWith("/") ? skillsDir : join(projectRoot, skillsDir))
+    : undefined;
+  const skillList = buildSkillList(resolvedSkillsDir);
+  const rendered = tpl.replace("{{SKILL_LIST}}", skillList);
+
+  const githubDir = join(projectRoot, ".github");
+  const copilotInstructionsPath = join(githubDir, "copilot-instructions.md");
+
+  if (!existsSync(githubDir)) mkdirSync(githubDir, { recursive: true });
+
+  writeCopilotInstructions(copilotInstructionsPath, rendered);
+
+  return { written: true, path: copilotInstructionsPath };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jenga-ai/agent",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Structured multi-agent development workflow for AI coding agents — scrum board, role-bounded scrum master / developer / tester agents, and 30+ slash-command skills. Works with Claude Code, GitHub Copilot, and Codex.",
   "type": "module",
   "publishConfig": {
@@ -16,12 +16,12 @@
     "postinstall": "node scripts/postinstall.js",
     "test": "bats tests/*.bats",
     "validate:npm-metadata": "bash scripts/validate_npm_metadata.sh",
-    "ui:dev": "npm run ui:dev --prefix project/app",
-    "ui:build": "npm run ui:build --prefix project/app",
-    "api:start": "npm run api:start --prefix project/app",
-    "api:dev": "npm run api:dev --prefix project/app",
-    "dashboard:start": "npm run dashboard:start --prefix project/app",
-    "dashboard:open": "npm run dashboard:open --prefix project/app"
+    "ui:dev": "npm run ui:dev --prefix project/app --",
+    "ui:build": "npm run ui:build --prefix project/app --",
+    "api:start": "npm run api:start --prefix project/app --",
+    "api:dev": "npm run api:dev --prefix project/app --",
+    "dashboard:start": "npm run dashboard:start --prefix project/app --",
+    "dashboard:open": "npm run dashboard:open --prefix project/app --"
   },
   "files": [
     "skills/",
@@ -31,7 +31,17 @@
     "templates/",
     "bin/",
     "lib/",
-    "mcp/",
+    "mcp/execute-ticket/*.js",
+    "mcp/execute-ticket/package.json",
+    "mcp/help/*.js",
+    "mcp/help/package.json",
+    "mcp/router/*.js",
+    "mcp/router/package.json",
+    "mcp/router/package-lock.json",
+    "mcp/router/README.md",
+    "mcp/training_runner/*.js",
+    "mcp/training_runner/package.json",
+    "mcp/training_runner/package-lock.json",
     "README.md",
     "LICENSE"
   ],
@@ -67,15 +77,6 @@
     "url": "https://knappkod.se/jenga-ai"
   },
   "license": "MIT",
-  "dependencies": {
-    "@huggingface/transformers": "^4.2.0"
-  },
-  "overrides": {
-    "sharp": "^0.34.5"
-  },
-  "comments": {
-    "audit": "sharp <0.35.0 and adm-zip <0.6.0 are transitive deps of @huggingface/transformers with no upstream fix available. Not exploitable in this context: only text feature-extraction pipeline is used — no image processing or ZIP handling at application boundary. Review when @huggingface/transformers ships a patched release."
-  },
   "devDependencies": {
     "bats": "^1.13.0"
   }

package/scripts/postinstall.js

@@ -32,6 +32,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { mirror } from '../lib/mirror.js';
+import { generateCopilotInstructions } from '../lib/generate-copilot-instructions.js';
 
 // ESM equivalent of __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -153,6 +154,26 @@ function main() {
     totalSkipped += result.skipped.length;
   }
 
+  // Bootstrap .github/copilot-instructions.md unconditionally, right after the mirror step —
+  // no interactive prompts, since postinstall runs unattended during `npm install`. Without
+  // this, a consumer whose very first action is a Copilot slash command (before ever running
+  // the separate `jenga init` CLI wizard) gets no `/skill-name` routing instructions at all
+  // (E46_S03_T01). `.agents/skills` is passed as the skills directory because that's the
+  // directory the mirror step above just populated, regardless of which agentTarget the user
+  // eventually picks in `jenga init`. The shared generator's idempotent marker-replace logic
+  // (lib/generate-copilot-instructions.js) means a later `jenga init` run — using the user's
+  // actual chosen skillsPath — safely refines this file without duplicating the JENGA block.
+  try {
+    const result = generateCopilotInstructions(consumerRoot, packageRoot, '.agents/skills');
+    if (result.skipped) {
+      console.log('  ⚠  templates/copilot-instructions.md.tpl not found — skipped .github/copilot-instructions.md bootstrap');
+    } else {
+      console.log('  ✓ .github/copilot-instructions.md bootstrapped');
+    }
+  } catch (e) {
+    console.log(`  ⚠  Could not bootstrap .github/copilot-instructions.md — ${e.message}`);
+  }
+
   // Write .jenga-version to record the installed version at consumer root
   fs.writeFileSync(versionFile, packageVersion + '\n', 'utf8');
 

package/skills/commit/SKILL.md

@@ -36,7 +36,17 @@ If `--inline` is absent **and** `JENGA_COMMIT_INLINE` is not set (or is not `1`)
 
 If no epic, task, or story has been implemented, exit with the message: "No implementation to commit."
 
-1. **Reconcile first** — Invoke the `/reconcile` skill before any other action, so the board is never committed in a drifted state.
+1. **Reconcile first, scoped to this commit** — Invoke the `/reconcile` skill before any other action, so the board is never committed in a drifted state.
+   - **Determine the scope to pass** (in order):
+     1. If `/commit` was invoked with an explicit epic/story/task id argument (e.g. `/commit E46`, `/commit E17_S04_T02`), use that id.
+     2. Otherwise, if the calling context already identifies a single task/story/epic just completed (e.g. a developer or tester agent's sender object naming `task_id`/`story_id`/`epic_id`, or a `/do` invocation for one task), use that id.
+     3. Otherwise, derive it from what's staged: run `git diff --cached --name-only` and filter to paths under `project/board/epics/`, `project/board/stories/`, and `project/board/tasks/`. Extract the id each matched filename encodes.
+        - If every extracted id shares a single common story-or-narrower ancestor (all belong to one story's own file plus any of its own tasks' files, or are all exactly one task's own file, or are all exactly one epic's own file with nothing narrower staged), use that single most-specific id (story/task id if present, else the epic id) as the scope.
+        - If matched ids span more than one distinct story, or more than one distinct epic, this case does not resolve — do not guess between them; fall through to case 4.
+        - **If no board files at all are staged, skip `/reconcile` entirely — do not fall through to case 4.** A commit that touches no board file cannot itself commit board drift, so there is nothing for a pre-commit reconcile to protect against; running a full unscoped scan here would be pure waste, not a safety net. This is distinct from the multi-item case immediately above, which still falls through to case 4 since board files genuinely are changing there.
+     4. Otherwise — no argument, no sender context, and staged board files span more than one distinct story or epic — fall back to unscoped `/reconcile` (full board), unchanged from prior behavior.
+   - **Invoke** `/reconcile <scope>` when a scope was determined in cases 1-3, unscoped `/reconcile` on the case-4 fallback, or skip the reconcile step entirely per case 3's no-board-files-staged outcome. Do not re-derive or duplicate `/reconcile`'s own default-scope-to-epic expansion here — passing a bare story or task id through is sufficient; `/reconcile` itself resolves that to the containing epic.
+   - **If `/reconcile` was skipped** (case 3's no-board-files-staged outcome) — continue silently to the next step, exactly as the no-drift outcome below.
    - **If reconcile detects and corrects drift** — inform the user what changed (e.g. demoted/promoted statuses, merged orphaned worktrees, cleaned `todo.md` entries) before proceeding.
    - **If reconcile finds no drift** — continue silently to the next step.
 

package/skills/dev-done/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: dev-done
+description: Commit the current work and immediately sync it into the .claude/ and .agents/ mirrors. Shortcut that chains /commit followed by /self-sync.
+keywords:
+  - dev done
+  - commit and sync
+  - commit and mirror
+  - done syncing
+examples:
+  - "dev-done E42_S04_T01"
+  - "commit this and sync the mirrors"
+---
+
+# Dev-Done — Commit, then Sync the Mirrors
+
+Chains `/commit <scope-id>` and `/self-sync`, the same "convenience shortcut" pattern `skills/lgtm/SKILL.md`
+uses for `/commit` + `/continue` — applied here to the commit -> mirror-sync sequence instead of the
+commit -> next-task sequence. Useful right after implementing a root-level framework change
+(`skills/`, `agents/`, `hooks/`, `scripts/`, `templates/`, `settings.json`), so the `.claude/` and
+`.agents/` mirrors never sit stale waiting on a manual `/self-sync` call.
+
+The deterministic decision of whether `/commit` halted early (nothing to commit) or completed
+normally lives in `skills/dev-done/scripts/classify-commit-outcome.sh`, not inline here — see that
+script's header for the exact contract.
+
+## Instructions
+
+1. Invoke the `/commit` skill with whatever scope-id argument `/dev-done` itself was given (e.g.
+   `/dev-done E42_S04_T01` invokes `/commit E42_S04_T01`) — the same EST scope-id argument contract
+   `/commit` already accepts (epic, story, or task id; see `skills/commit/SKILL.md`). Capture its full
+   output text.
+
+2. Pass the captured output to the classifier script:
+   ```
+   skills/dev-done/scripts/classify-commit-outcome.sh <<< "$COMMIT_OUTPUT"
+   ```
+
+3. If the script exits `1` (HALT): print its stdout — the exact message `No implementation to
+   commit.` — to the user, and stop. Do **not** invoke `/self-sync`.
+
+4. If the script exits `0` (PROCEED): invoke the `/self-sync` skill and wait for it to finish. This
+   happens regardless of whether `/commit` reported drift or doc-sync findings along the way — those
+   are informational, not blocking (see `skills/commit/SKILL.md`).
+
+5. Report both steps' output to the user in sequence — the commit result first, then the self-sync
+   summary.