@skyf0xx/hedgehog 6.2.9 → 6.2.11

package/bin/cli.mjs

@@ -13,10 +13,11 @@
 //   npx @skyf0xx/hedgehog update                       refresh the installed agents + skills
 //   npx @skyf0xx/hedgehog --help
 
-import { cp, mkdir, access, readdir, stat, rm, readFile, writeFile } from 'node:fs/promises';
+import { cp, mkdir, access, readdir, stat, rm, readFile, writeFile, mkdtemp } from 'node:fs/promises';
 import { constants, existsSync, realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, relative, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
 import { spawn, execFileSync } from 'node:child_process';
 import { dbInit, DB_PATH, dbAbsPath, openDb, openDbAt } from '../src/db/init.mjs';
 import { loadCore, lintCore, isModuleAxis } from '../src/db/core.mjs';
@@ -121,6 +122,40 @@ const BLOCKED_REASON_LABELS = {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = resolve(__dirname, '..');
+
+// The copywriting core never installs into the directory it was invoked
+// from — every draft it produces is ephemeral scratch, and only the
+// finished piece is meant to reach the user's real project (as a plain
+// file, copied out by hedgehog-copywriting-loop's own courtesy-export
+// step). Relying on every caller (an agent reading a skill's prose, a
+// human typing the command by hand) to remember to cd into a scratch
+// directory first is exactly the kind of instruction that gets skipped
+// under context pressure — so `init --copywriting` enforces it here
+// instead, unconditionally, before DEST_ROOT is ever read. This has to
+// run before any other module-level state is computed from `process.cwd()`
+// — a raw argv scan rather than the full async arg parser lower in this
+// file, since nothing below has run yet at this point in module load.
+const ORIGDIR = process.cwd();
+{
+  // Catches both the shorthand (`--copywriting`) and the generic named-core
+  // form (`--core copywriting`, `--core=copywriting`) — namedCore()/
+  // coreFlags() do the real resolution later, async, off the registry, but
+  // this has to run synchronously before that and before DEST_ROOT below,
+  // so it matches the raw argv directly rather than waiting for it.
+  const rest = process.argv.slice(2);
+  const coreIdx = rest.indexOf('--core');
+  const isCopywriting =
+    rest.includes('--copywriting') ||
+    rest[coreIdx + 1] === 'copywriting' ||
+    rest.includes('--core=copywriting');
+  if (isCopywriting) {
+    const scratch = await mkdtemp(join(tmpdir(), 'hedgehog-copywriting-'));
+    process.chdir(scratch);
+    // No ANSI helpers yet — `dim` etc. are defined further down, after
+    // DEST_ROOT, and this has to run before DEST_ROOT is computed.
+    console.log(`  (copywriting installs to a scratch directory, never here — using ${scratch})`);
+  }
+}
 const DEST_ROOT = process.cwd();
 
 // The version of the payload this CLI carries — what `init` and
@@ -865,9 +900,22 @@ async function init({ force, core, host = DEFAULT_HOST, hostOnly = false, global
       `  0. ${bold(`npx @skyf0xx/hedgehog@latest update`)} ${dim(`(picks up ${globalInstall.latest} before intake begins)`)}`,
     );
   }
-  // A core that landed a workspace landed its root package.json with it,
-  // so there are dependencies to install before the first commit.
-  if (core?.manifest.workspace) {
+  // Copywriting never lands anywhere the caller can see directly (see the
+  // chdir into a scratch tempdir at module load, above) — the ordinary
+  // "commit here, describe what you want to build" steps assume a project
+  // the human is looking at, which this scratch directory isn't. Point at
+  // the loop skill instead; it owns pnpm install, the draft/checkCopy()
+  // cycle, and the courtesy export of the finished piece back to ORIGDIR.
+  if (core?.manifest.name === 'copywriting') {
+    console.log(
+      `  1. Read ${bold(`${HOSTS[host].skillsDir}/hedgehog-copywriting-loop/SKILL.md`)} and follow it`,
+    );
+    console.log(dim(`     for everything from here, staying inside ${bold(DEST_ROOT)}.`));
+    console.log(
+      dim(`     The finished piece lands back at ${bold(ORIGDIR)} on its own — nothing`),
+    );
+    console.log(dim('     else needs doing there.'));
+  } else if (core?.manifest.workspace) {
     // `pnpm install` before the first commit, not after it. The core's
     // commit gate is lefthook, and lefthook's hooks are written by its
     // own postinstall — so a commit made before the install is a commit
@@ -900,19 +948,23 @@ async function init({ force, core, host = DEFAULT_HOST, hostOnly = false, global
   // the session that ran this install — no restart, no dependence on whether
   // the harness re-scans its agent directory, and no chance of a bare
   // `planner` resolving to an unrelated global agent of the same name.
-  const agents = HOSTS[host].agentsDir;
-  const skills = HOSTS[host].skillsDir;
-  console.log(
-    dim(
-      `     Read ${bold(`${agents}/planner.md`)} and follow it — it runs planning\n` +
-        `     intake (${skills}/hedgehog-planning-intake/SKILL.md), then hands\n` +
-        `     off to ${agents}/bootstrap.md.\n` +
-        `     Some hosts register agents/skills once, at session start: if a\n` +
-        `     later dispatch by name reports one of these as not found, read\n` +
-        `     its file directly instead — it becomes dispatchable by name after\n` +
-        `     a session restart or a fresh context.`,
-    ),
-  );
+  // Copywriting's own branch above already named its hand-off (the loop
+  // skill, not planner/bootstrap — this core has no bootstrap step).
+  if (core?.manifest.name !== 'copywriting') {
+    const agents = HOSTS[host].agentsDir;
+    const skills = HOSTS[host].skillsDir;
+    console.log(
+      dim(
+        `     Read ${bold(`${agents}/planner.md`)} and follow it — it runs planning\n` +
+          `     intake (${skills}/hedgehog-planning-intake/SKILL.md), then hands\n` +
+          `     off to ${agents}/bootstrap.md.\n` +
+          `     Some hosts register agents/skills once, at session start: if a\n` +
+          `     later dispatch by name reports one of these as not found, read\n` +
+          `     its file directly instead — it becomes dispatchable by name after\n` +
+          `     a session restart or a fresh context.`,
+      ),
+    );
+  }
   console.log();
   if (core) {
     console.log(dim(`Core: ${bold(core.manifest.name)} ${dim(`(${core.version})`)}.`));
@@ -2250,8 +2302,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 +2318,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.9",
+  "version": "6.2.11",
   "description": "Install the Hedgehog build discipline (agents + skills) into a repo, for Claude Code, Cursor, or Gemini CLI.",
   "type": "module",
   "repository": {
@@ -17,8 +17,7 @@
     "lint": "eslint .",
     "check": "npm run lint && node scripts/check.mjs",
     "repro": "node --experimental-sqlite repro/run-all.mjs",
-    "release": "node scripts/bump-package-version.mjs",
-    "release:plugin": "node scripts/bump-plugin-version.mjs"
+    "release": "node scripts/bump-package-version.mjs"
   },
   "files": [
     "bin",

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

@@ -1,6 +1,6 @@
 {
   "name": "hedgehog",
-  "version": "6.2.9",
+  "version": "6.2.11",
   "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)) {