@skyf0xx/hedgehog 6.2.8 → 6.2.10

package/bin/cli.mjs

@@ -2250,8 +2250,12 @@ async function verifyCommand(args) {
   }
 
   // Fires once per project — see community.mjs. Deliberately last: after
-  // the gate's own output, not before it.
-  const starJustShown = await shouldPromptForStar(DEST_ROOT, { intentComplete: result.intentComplete });
+  // the gate's own output, not before it. Suppressed by HEDGEHOG_NO_COMMUNITY_PROMPT
+  // for ephemeral workflows (temp-dir installs with no persistent .hedgehog/ to track
+  // cooldown state) that would otherwise re-fire on every invocation.
+  const starJustShown = process.env.HEDGEHOG_NO_COMMUNITY_PROMPT
+    ? false
+    : await shouldPromptForStar(DEST_ROOT, { intentComplete: result.intentComplete });
   if (starJustShown) {
     console.log(formatStarPrompt());
     console.log('');
@@ -2262,7 +2266,8 @@ async function verifyCommand(args) {
   // just showed the star prompt for the first time. See
   // shouldPromptForShowcase for why `starJustShown` has to come from
   // here rather than being re-derived from state.
-  if (await shouldPromptForShowcase(DEST_ROOT, { intentComplete: result.intentComplete, starJustShown })) {
+  if (!process.env.HEDGEHOG_NO_COMMUNITY_PROMPT &&
+      (await shouldPromptForShowcase(DEST_ROOT, { intentComplete: result.intentComplete, starJustShown }))) {
     console.log(formatShowcasePrompt());
     console.log('');
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyf0xx/hedgehog",
-  "version": "6.2.8",
+  "version": "6.2.10",
   "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.8",
+  "version": "6.2.10",
   "description": "Hedgehog build discipline: ordered, tested, verified build steps.",
   "contextFileName": "GEMINI.md"
 }

package/src/registry/fetch.mjs

@@ -41,6 +41,12 @@ export const CORE_CACHE_ROOT = join(homedir(), '.hedgehog', 'cores');
 // exercised end to end before it is published.
 const SOURCE_ENV = 'HEDGEHOG_CORE_SOURCE';
 
+// Skip cache (both reads and writes) when set; every invocation gets a fresh
+// npm pack with no persistence to ~/.hedgehog/cores/. Useful when the
+// caller's use of the fetched core is ephemeral or when accurate npm
+// download stats are needed.
+const NO_CACHE_ENV = 'HEDGEHOG_CORE_NO_CACHE';
+
 const exists = (p) =>
   access(p, constants.F_OK).then(
     () => true,
@@ -83,6 +89,13 @@ export async function fetchCore(entry) {
     throw err;
   }
 
+  // When NO_CACHE_ENV is set, skip cache entirely and return the staged
+  // extraction directly, leaving staged.tmp in place (since staged.root
+  // lives inside it).
+  if (process.env[NO_CACHE_ENV]) {
+    return { ...read, root: staged.root, version };
+  }
+
   // Another install may have cached this exact version between the pack
   // and now; its copy is as good as this one, so keep it and drop ours.
   if (await exists(cached)) {

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: