@skyf0xx/hedgehog 6.2.6 → 6.2.8

package/package.json

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

package/src/agents/bootstrap.md

@@ -1,6 +1,6 @@
 ---
 name: bootstrap
-description: Use once per invocation, at the start of a new Hedgehog project, to land the workspace for whichever core `planner` selected at Phase 0 — the first real workspace this project gets, since `init` with no explicit core flag lands the shared agents/skills/build-graph payload and leaves the workspace to bootstrap. Reads the chosen core's own bootstrap skill, installed from that core's package, and follows it: how many steps Bootstrap takes and what each one lands are that skill's to state, not this agent's. Not for per-phase/per-module work — that's the core's own loop skill and its agents. Skip entirely if the core's workspace already exists, per the already-ran check the core's bootstrap skill opens with.
+description: Use once per invocation, at the start of a new Hedgehog project, to land the workspace for whichever core `planner` selected at Phase 0 — the first real workspace this project gets, since `init` with no explicit core flag lands the shared agents/skills/build-graph payload and leaves the workspace to bootstrap. Reads the chosen core's own bootstrap skill, installed from that core's package, and follows it: how many steps Bootstrap takes and what each one lands are that skill's to state, not this agent's. Not for per-phase/per-module work — that's the core's own loop skill and its agents. Skip entirely if the core's workspace already exists, per the already-ran check the core's bootstrap skill opens with. Never dispatched for copywriting — that core ships no bootstrap skill; `init --copywriting` lands its whole workspace at install time, and its own planning intake runs `hedgehog plan` directly instead of handing off here.
 model: sonnet
 color: green
 tools: Read, Glob, Grep, Edit, Write, Bash

package/src/agents/planner.md

@@ -21,7 +21,9 @@ You run on two paths, and Workflow step 2 decides which:
 
 - **First run** (the graph holds no intents): **Phase 0 — core
   selection**, the gate below, then **Phase 1 — planning intake** in the
-  shape the chosen core defines, then the `bootstrap` handoff.
+  shape the chosen core defines, then the `bootstrap` handoff — except
+  copywriting, which has no bootstrap skill and whose planning intake
+  runs `hedgehog plan` itself; see step 9.
 - **Re-entry** (the graph already holds intents): new scope entering play
   on a project that's already been built or is mid-build, on a core with
   a module axis to add an intent to (full-stack-app, authored). The core
@@ -88,7 +90,8 @@ memory of what a core is. Read every entry before choosing; the first
 plausible match is not the answer until the rest have been ruled out.
 A core whose `when` fits and whose `flag` is listed is chosen by name
 and handed to `bootstrap`, which installs that core's package and
-follows the bootstrap skill it ships.
+follows the bootstrap skill it ships — except copywriting, which ships
+no bootstrap skill; see step 9.
 
 **Before matching against `when` paragraphs, ask up to three
 clarifying questions if the description alone doesn't already settle
@@ -272,7 +275,12 @@ the first-run shape; on re-entry, run `hedgehog-planning-intake`'s
   full-stack-app before that Phase 0 begins. `hedgehog-copywriting-loop`
   owns `.hedgehog/copy/00-brief.md` and this core's own Confirm & Lock
   stage; `.hedgehog/BMAD/` is written by the shared Phase 0 in
-  `hedgehog-planning-intake`.
+  `hedgehog-planning-intake`. This core's own Confirm & Lock runs
+  `hedgehog plan` itself and does not hand off to `bootstrap` — its
+  workspace (`scripts/check-copy/` and `core.yaml`) is already fully
+  installed by `init --copywriting`, before planning intake ever starts,
+  and this core ships no bootstrap skill. Step 9 below does not apply to
+  it; the core's own loop skill picks up from here directly.
 - **`deepseek-harness`** → no BMAD shelf runs on this core, and none of
   `hedgehog-planning-intake` applies. Intake is mechanical, owned
   entirely by `hedgehog-dsh-loop`'s own Planning intake section: confirm
@@ -487,6 +495,10 @@ as full-stack-app's Auth/Queue/Mobile trio.
    run**, don't run `plan` yet — no core is installed until step 9's
    `bootstrap` handoff lands one, and `plan` requires `core.yaml` to
    exist. Leave the written intents `proposed` and continue to step 8.
+   **Copywriting is the one exception**: its own Confirm & Lock (see the
+   core-specific procedures above) already ran `hedgehog plan` as part
+   of step 6, since its `core.yaml` is on disk before planning intake
+   ever starts — nothing left to defer here.
 8. **Commit planning intake's output as one commit** — not on the
    adoption re-entry path, where `hedgehog-adopt` already committed its
    own work as `chore(planning): adopt change` (step 2). Elsewhere:
@@ -502,18 +514,22 @@ as full-stack-app's Auth/Queue/Mobile trio.
    only). Write these with the `no-history-in-output` skill: current
    state only, no narration of the intake conversation. This is planning
    intake's own unit of work, landed before `bootstrap` touches anything.
-9. **First run only, and not on the brownfield path — hand off to the
-   `bootstrap` agent** once the commit lands. It scaffolds the chosen
-   core's workspace (and, for full-stack-app, whichever add-ons are on;
-   for pwa-app, whichever of sync/remote entities is on) before any build
-   step starts. Once that workspace exists, `core.yaml` exists too — this
-   is the point at which the `hedgehog plan` step 7 deferred on a first
-   run can finally succeed. `bootstrap` runs it before closing (see
-   `bootstrap.md`'s "Closing Bootstrap"), so the intents planner wrote are
-   compiled into tasks before the core's loop skill picks anything up. On
-   re-entry on any other core the workspace already exists and step 7
-   already ran `plan`: hand straight to that core's loop skill instead,
-   which picks the new work up from `hedgehog next`.
+9. **First run only, not on the brownfield path, and not on
+   copywriting — hand off to the `bootstrap` agent** once the commit
+   lands. It scaffolds the chosen core's workspace (and, for
+   full-stack-app, whichever add-ons are on; for pwa-app, whichever of
+   sync/remote entities is on) before any build step starts. Once that
+   workspace exists, `core.yaml` exists too — this is the point at which
+   the `hedgehog plan` step 7 deferred on a first run can finally
+   succeed. `bootstrap` runs it before closing (see `bootstrap.md`'s
+   "Closing Bootstrap"), so the intents planner wrote are compiled into
+   tasks before the core's loop skill picks anything up. On re-entry on
+   any other core the workspace already exists and step 7 already ran
+   `plan`: hand straight to that core's loop skill instead, which picks
+   the new work up from `hedgehog next`. **On copywriting**, first run or
+   not, there is no `bootstrap` handoff at all — its own Confirm & Lock
+   already ran `plan` (see the core-specific procedures above); hand
+   straight to `hedgehog-copywriting-loop` instead.
 10. **Return a summary**: which core (naming it as authored or adopted,
     if it is), the intents added (or subject statement, for
     landing-page), any open questions.

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

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

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.