@skyf0xx/hedgehog 6.2.7 → 6.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyf0xx/hedgehog",
-  "version": "6.2.7",
+  "version": "6.2.9",
   "description": "Install the Hedgehog build discipline (agents + skills) into a repo, for Claude Code, Cursor, or Gemini CLI.",
   "type": "module",
   "repository": {

package/src/agents/planner.md

@@ -62,16 +62,17 @@ present bypassing it as an equally-weighted option alongside following
 it — that smuggles the bypass in as the path of least resistance instead
 of surfacing the actual conflict.
 
-"Don't ask clarifying questions" is the common case, and on full-stack-app
-or an authored core it has a defined destination once the user has chosen
-it: **compressed intake** (`hedgehog-planning-intake`'s Phase 0). Surface
-the conflict first, exactly as above — compressed intake is what the
-user's answer can select, never what you recommend to avoid the
-conversation. Say what it costs when you name it: one batched round of
-questions instead of the shelf, a thinner archive, and an architecture
-(on an authored core) designed from a brief rather than elicited drivers.
-Landing-page has no such destination — see that skill for why — so there
-the conflict is surfaced and resolved with the user, not routed.
+"Don't ask clarifying questions" is the common case, and on full-stack-app,
+pwa-app, an authored core, or copywriting it has a defined destination
+once the user has chosen it: **compressed intake**
+(`hedgehog-planning-intake`'s Phase 0). Surface the conflict first,
+exactly as above — compressed intake is what the user's answer can
+select, never what you recommend to avoid the conversation. Say what it
+costs when you name it: one batched round of questions instead of the
+shelf, a thinner archive, and an architecture (on an authored core)
+designed from a brief rather than elicited drivers. Landing-page has no
+such destination — see that skill for why — so there the conflict is
+surfaced and resolved with the user, not routed.
 
 ## Phase 0 — which core applies
 

package/src/hosts/gemini/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgehog",
-  "version": "6.2.7",
+  "version": "6.2.9",
   "description": "Hedgehog build discipline: ordered, tested, verified build steps.",
   "contextFileName": "GEMINI.md"
 }

package/src/skills/hedgehog-planning-intake/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: hedgehog-planning-intake
-description: Use on any core for first-run planning intake — Phase 0 runs the vendored BMAD-METHOD planning shelf, shared by every core, and Phase 1 (mining `04-prd.md` into intent records plus the Add-ons/sync-and-remote-entities decision) is full-stack-app's and pwa-app's shared procedure — identical mechanics, a different decision at step 5/8. Phase 0 also defines compressed intake, the path a user's explicit "just build it" choice takes on full-stack-app, pwa-app, and authored cores: one batched round of questions in place of the shelf, writing the same archive at the same path so Phase 1, `ux-planner`, and the Re-entry pass all keep their documented source. Also use for the Re-entry pass, which mines new scope into additional intents without re-running the shelf, on any core with a module axis to add an intent to (full-stack-app, pwa-app, authored) — landing-page has none, so its own new-scope path runs through `hedgehog-landing-loop`'s Correction Protocol instead. Invoked by the `planner` agent, which decides the path; don't run standalone. landing-page runs this skill's Phase 0 on first run, then mines the same archive through `hedgehog-landing-loop`'s own planning-intake section, that core's counterpart to this skill's Phase 1. copywriting runs this skill's Phase 0 the same way, then mines the same archive through `hedgehog-copywriting-loop`'s own planning-intake section into a what/audience/register brief — no module axis, so its own new-scope path runs through that loop's Correction Protocol rather than the Re-entry pass below. An authored core runs this skill's Phase 0, then `hedgehog-core-design`, then this skill's Phase 1 mining against the designed layer sequence. A brownfield adoption (`hedgehog-adopt`) never runs this skill's shelf at all — the drivers BMAD elicits are already settled facts of a repo that already exists.
+description: Use on any core for first-run planning intake — Phase 0 runs the vendored BMAD-METHOD planning shelf, shared by every core, and Phase 1 (mining `04-prd.md` into intent records plus the Add-ons/sync-and-remote-entities decision) is full-stack-app's and pwa-app's shared procedure — identical mechanics, a different decision at step 5/8. Phase 0 also defines compressed intake, the path a user's explicit "just build it" choice takes on full-stack-app, pwa-app, authored, and copywriting cores: one batched round of questions in place of the shelf, writing a thinned archive at the same paths so Phase 1 (or, on copywriting, that core's own mining step), `ux-planner`, and the Re-entry pass all keep their documented source. Also use for the Re-entry pass, which mines new scope into additional intents without re-running the shelf, on any core with a module axis to add an intent to (full-stack-app, pwa-app, authored) — landing-page has none, so its own new-scope path runs through `hedgehog-landing-loop`'s Correction Protocol instead. Invoked by the `planner` agent, which decides the path; don't run standalone. landing-page runs this skill's Phase 0 on first run, then mines the same archive through `hedgehog-landing-loop`'s own planning-intake section, that core's counterpart to this skill's Phase 1. copywriting runs this skill's Phase 0 the same way (full or compressed), then mines the same archive through `hedgehog-copywriting-loop`'s own planning-intake section into a what/audience/register brief — no module axis, so its own new-scope path runs through that loop's Correction Protocol rather than the Re-entry pass below. An authored core runs this skill's Phase 0, then `hedgehog-core-design`, then this skill's Phase 1 mining against the designed layer sequence. A brownfield adoption (`hedgehog-adopt`) never runs this skill's shelf at all — the drivers BMAD elicits are already settled facts of a repo that already exists.
 ---
 
 # Hedgehog Planning Intake
@@ -102,7 +102,7 @@ states the source repo, pinned version (`vendor-skills/BMAD/ATTRIBUTION.md` has
 the pinned commit), date, which intake mode ran (`full`, below, or
 `compressed`), and which skills ran.
 
-### Compressed intake (full-stack-app, pwa-app, authored core)
+### Compressed intake (full-stack-app, pwa-app, authored core, copywriting)
 
 A user who opens with "just build it" — no clarifying questions — is
 asking for something Phase 0's live elicitation can't give them.
@@ -132,6 +132,38 @@ trigger in the user's brief, or asked directly in that one round.
 Compressed intake compresses BMAD's elicitation, never `planner`'s gate;
 a boolean left as a guess is the same error here as on a full run.
 
+**On copywriting**, the batched round covers exactly what
+`hedgehog-copywriting-loop`'s own mining step needs and can't infer from
+the user's request: what's being written (the concrete piece), the
+audience, and the register. There's no Add-ons-shaped decision here —
+copywriting has no module axis and no boolean gate, so the round is
+smaller than full-stack-app's or pwa-app's: three questions, or fewer
+where the request already answers one. A short, low-stakes piece (a
+single UI microcopy string, a one-off product-announcement paragraph) is
+the case this mode exists for — the acceptance criterion this issue
+names is a batched round in place of the full shelf for exactly that
+shape of request, not a lighter version of the shelf itself.
+
+Write a thinned archive at the same paths `hedgehog-copywriting-loop`'s
+mining step (its planning-intake section, step 2) already reads —
+`02-brief.md` and `03-prfaq.md`, not the PRD or UX spec, since
+copywriting's mining draws from those two, never `04-prd.md`:
+
+```
+.hedgehog/BMAD/
+  00-manifest.md   # mode: compressed, date, what the batched round asked
+  02-brief.md      # what's being written + audience, from the brief + batched round
+  03-prfaq.md      # register, from the brief + batched round
+```
+
+`01-brainstorming.md`, `04-prd.md`, `05-ux-spec/`, and `06-research.md`
+are not written, for the same reason full-stack-app's compressed intake
+skips its own unused files: `00-manifest.md` naming them as not-run is
+the record. `hedgehog-copywriting-loop`'s mining step reads whichever
+files the archive holds exactly as it does on a full run — it draws from
+`02-brief.md` and `03-prfaq.md` either way, so a thinned archive changes
+nothing about how that step runs, only how much material informed it.
+
 Write the manifest and the PRD always, and the experience spec where the
 brief gives it something to say — at the same path and in the same
 layout:

package/vendor-skills/BMAD/ATTRIBUTION.md

@@ -66,8 +66,21 @@ meaning this directory (`vendor-skills/BMAD/`) — used to address the shared
 scripts (`{bmad-root}/scripts/memlog.py`, etc.) without reaching outside
 this vendored tree.
 
+## Local changes (not upstream)
+
+- `core-skills/bmad-brainstorming/customize.toml` and
+  `core-skills/bmad-brainstorming/references/{mode-autonomous,finalize}.md`
+  carry a `keepsake_format` workflow key (`"html"` default,
+  `"markdown-only"` opt-out) not present upstream: Ideate-for-me and
+  headless mode otherwise auto-generate an HTML keepsake with no way to
+  opt out in advance, which is unwanted work on a project whose
+  deliverables are markdown/prose only (skyf0xx/hedgehog#386). A
+  re-vendor pass must re-apply this key to the freshly-fetched files
+  rather than letting it silently disappear.
+
 ## Re-vendoring
 
 Pinned deliberately. Re-vendoring against a newer BMAD-METHOD commit is a
 manual act: repeat the fetch against the new ref, re-apply the strip step
-above, and update this file's pinned commit and date.
+above, re-apply "Local changes" above, and update this file's pinned
+commit and date.

package/vendor-skills/BMAD/core-skills/bmad-brainstorming/customize.toml

@@ -60,6 +60,17 @@ favorite_techniques = []
 #   description = "Start from the compliance constraint and brainstorm what becomes possible only because of it — turn the rule into a generative frame rather than a limit."
 additional_techniques = []
 
+# Format for the Ideate-for-me / headless default artifact. "html" (default)
+# auto-generates the imaginative HTML keepsake with no asking. "markdown-only"
+# skips it and produces the intent doc (brainstorm-intent.md) instead — for a
+# project whose deliverables are markdown/prose only, where an HTML file is
+# unwanted work rather than a bonus. Facilitator and Creative Partner modes
+# are unaffected either way: every artifact there is already opt-in.
+#
+# Example (set in team/user override TOML, e.g. a copywriting-core project):
+#   keepsake_format = "markdown-only"
+keepsake_format = "html"
+
 # Session output location. The running log and any final artifacts land inside
 # `{output_dir}/{output_folder_name}/`. `{topic_slug}` is filled from the session
 # topic so each topic gets its own folder — a user can brainstorm several topics

package/vendor-skills/BMAD/core-skills/bmad-brainstorming/references/finalize.md

@@ -13,11 +13,11 @@ Record the insights and chosen directions with `uv run {bmad-root}/scripts/memlo
 
 ## Artifacts
 
-In **Ideate for me** (and headless), the imaginative HTML keepsake is the deliverable you promised — produce it automatically, no asking; the other artifacts below stay opt-in. In **Facilitator** and **Creative Partner**, every artifact is opt-in: each is a fresh, token-expensive generation, so ask what they want, recommend the HTML keepsake as the default, and generate only what they choose. Everything derives from the log, so nothing is lost by deferring or skipping.
+In **Ideate for me** (and headless), check `{workflow.keepsake_format}`. When it's `"html"` (the default), the imaginative HTML keepsake is the deliverable you promised — produce it automatically, no asking; the other artifacts below stay opt-in. When it's `"markdown-only"`, skip the HTML keepsake entirely and produce the intent doc instead, with no ask — a project setting this override has already decided HTML is unwanted work, not a preference to re-confirm per session. In **Facilitator** and **Creative Partner**, every artifact is opt-in regardless of `keepsake_format`: each is a fresh, token-expensive generation, so ask what they want — recommend the HTML keepsake as the default unless `keepsake_format` is `"markdown-only"`, in which case don't offer it — and generate only what they choose. Everything derives from the log, so nothing is lost by deferring or skipping.
 
 **Delegate each artifact to a subagent.** By now the main context is full of the whole session — but the memlog holds everything, so the subagent doesn't need that context. Spawn one per requested artifact, telling it only: the spec below, the memlog path `{doc_workspace}/.memlog.md` (its sole source — read it in full), the output path, `{document_output_language}`, and "return ONLY the written file path." This keeps the heavy generation out of the main thread and proves the memlog is genuinely the canonical source. (Subagents can't spawn subagents — run these from here.)
 
-- **Imaginative HTML keepsake (recommended default).** A single self-contained `brainstorm.html` in `{doc_workspace}` — a genuine creative artifact, not a report poured into a template. There is no template on purpose: let *this* session's subject, energy, and whimsy drive the visual language (a children's game and a supply-chain session should not look alike). Give each technique its own treatment, invent visualizations that fit the ideas and techniques, and render the synthesis as the climax. Inline all CSS and any JS; no external dependencies. Open it once complete.
+- **Imaginative HTML keepsake (recommended default, skipped when `{workflow.keepsake_format}` is `"markdown-only"`).** A single self-contained `brainstorm.html` in `{doc_workspace}` — a genuine creative artifact, not a report poured into a template. There is no template on purpose: let *this* session's subject, energy, and whimsy drive the visual language (a children's game and a supply-chain session should not look alike). Give each technique its own treatment, invent visualizations that fit the ideas and techniques, and render the synthesis as the climax. Inline all CSS and any JS; no external dependencies. Open it once complete.
 - **Intent doc.** A succinct `brainstorm-intent.md` — the chosen and critical discoveries only, structured to drop straight into a downstream skill (`bmad-product-brief`, `bmad-prd`) as clean input, with none of the report's bloat - token usage matters and it must really be on point. Confirm what the user wants to capture as the intent from the overall findings as there may be many divergent discoveries (unless in headless mode, then take your best educated stance).
 - **Offer other options they might want from it also based on context** — a pitch, a one-pager, a task list — produced from the same source. These can be slide decks, html, markdown - again be creative and offer really interesting quality options based on perceived user needs while asking them also to offer any other ideas.
 

package/vendor-skills/BMAD/core-skills/bmad-brainstorming/references/mode-autonomous.md

@@ -4,7 +4,7 @@ The user handed you the topic and wants to see what you come up with on your own
 
 - **Run a real divergent session yourself.** If the user supplied techniques (e.g. a composed prompt pasted from the selector page), honor those first; otherwise pick and run techniques on your own (use `brain.py` as in `## Choosing Techniques`, but *you* choose — no menu for the user). Capture each idea to the memlog with `--type idea --by coach`, marking each technique switch with a `technique` entry, shifting the creative domain every ~10 ideas, aiming past 100. Push past the obvious.
 - **Don't pepper the user with questions** — this is your run. One quick confirm of topic and goal up front is plenty.
-- **When it's mined out, synthesize and produce the keepsake.** Go to `## Wrap-Up` (`references/finalize.md`): record the insights, mark the memlog complete, and **auto-generate the imaginative HTML keepsake — don't ask first; the keepsake is the result you promised to show them.** Offer the other artifacts (intent doc, etc.) after.
+- **When it's mined out, synthesize and produce the keepsake.** Go to `## Wrap-Up` (`references/finalize.md`): record the insights, mark the memlog complete, and **auto-generate the imaginative HTML keepsake — don't ask first; the keepsake is the result you promised to show them** — unless `{workflow.keepsake_format}` is `"markdown-only"`, in which case skip the HTML keepsake and produce the intent doc instead, also with no asking. Offer the other artifacts (intent doc, etc.) after.
 - **Then, because a human is here, offer to keep going together.** They may want to push an idea further or react to what you found — if so, switch into **Facilitator** or **Creative Partner** (load that frame), **record the switch in the memlog** so a resume restores the new stance — `uv run {bmad-root}/scripts/memlog.py set --workspace {doc_workspace} --key mode --value <facilitator|partner>` — and continue from the same memlog.
 
 This is the interactive sibling of headless mode (`references/headless.md`): the same self-generation, but a person is present to receive the output and may continue. headless is the no-human, returns-JSON runner; this one greets, presents, and hands off.