@skyf0xx/hedgehog 5.3.0 → 5.3.2

package/bin/cli.mjs

@@ -1302,9 +1302,10 @@ async function warnSingularModuleId(intent) {
 
   console.log(
     `\n${yellow(bold('Module id looks singular.'))} On this core the intent id is ${bold('{module}')} in\n` +
-      `every layer's scope, and the generators take it plural — so ${bold(intent.id)} compiles\n` +
-      `scope for ${bold(`${intent.id}/`)} while the scaffold command writes ${bold(`${intent.id}s/`)}.\n` +
-      `If ${bold(`${intent.id}s`)} is the name you meant, fix it now, before ${bold('hedgehog plan')}:\n` +
+      `every layer's scope. On some cores the generator pluralizes it, so ${bold(intent.id)} would\n` +
+      `compile scope for ${bold(`${intent.id}/`)} while the scaffold command writes ${bold(`${intent.id}s/`)} — worth\n` +
+      `checking this core's own generator before ${bold('hedgehog plan')}. If ${bold(`${intent.id}s`)} is the name you\n` +
+      `meant, it's still cheap to fix now:\n` +
       `  ${dim(`git mv ${INTENTS_DIR}/${intent.id}.json ${INTENTS_DIR}/${intent.id}s.json`)}\n` +
       `  ${dim(`# edit "id" and every ${intent.id.toUpperCase()}-* requirement id, then:`)}\n` +
       `  ${dim('hedgehog db rebuild')}\n`,
@@ -1352,11 +1353,12 @@ function warnSingularModuleIdsAtPlan(core, db) {
   console.log(
     `${yellow(bold(many ? `${singular.length} module ids look singular.` : 'Module id looks singular.'))} ` +
       `On this core an intent id is ${bold('{module}')} in\n` +
-      `every layer's scope, and the generators take it plural — so ${many ? 'each of these compiles' : 'this compiles'}\n` +
-      `scope for a directory the scaffold command will never write:\n` +
-      singular.map((id) => `  ${bold(id)} ${dim(`— scope ${id}/, scaffold writes ${id}s/`)}`).join('\n') +
+      `every layer's scope. On some cores the generator pluralizes it, so ${many ? 'each of these would compile' : 'this would compile'}\n` +
+      `scope for a directory the scaffold command might never write:\n` +
+      singular.map((id) => `  ${bold(id)} ${dim(`— scope ${id}/, generator may instead write ${id}s/`)}`).join('\n') +
       `\n\nThis is a naming convention, not a rule — ${bold('billing')} and ${bold('search')} are ` +
-      `legitimately\nsingular. If the plural is what you meant, it is still cheap to fix:\n` +
+      `legitimately\nsingular, and not every core's generator pluralizes at all — check this core's own\n` +
+      `generator before assuming it does. If the plural is what you meant, it is still cheap to fix:\n` +
       singular
         .map(
           (id) =>

package/package.json

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

package/src/db/next.mjs

@@ -394,14 +394,29 @@ export function scopePackageRoot(glob, module) {
 // `exists` is injected so this module keeps no filesystem dependency of
 // its own; the CLI passes a real one and the packet degrades to no
 // section when a caller supplies none.
+//
+// A layer can carry more than one glob into the same real package — e.g.
+// `plugins/{module}/package.json` and `plugins/{module}/lib/**` both
+// belong to one package, but the second glob's own literal prefix ends
+// at `lib`, a build-output directory that never holds a `package.json`
+// of its own. Naively treating every such root as first-arrival would
+// flag `lib/` as a second package needing its own scaffold. A root
+// nested under another of this task's own roots is never a package
+// boundary — only the shallowest root in each chain is.
 export function firstArrivalPackages(task, exists) {
   if (!exists) return [];
-  const roots = new Set();
+  const allRoots = new Set();
+  const missing = new Set();
   for (const glob of JSON.parse(task.scope_globs)) {
     const root = scopePackageRoot(glob, task.module);
-    if (root && !exists(`${root}/package.json`)) roots.add(root);
+    if (!root) continue;
+    allRoots.add(root);
+    if (!exists(`${root}/package.json`)) missing.add(root);
   }
-  return [...roots].sort();
+  const outermost = [...missing].filter(
+    (root) => ![...allRoots].some((other) => other !== root && root.startsWith(`${other}/`)),
+  );
+  return outermost.sort();
 }
 
 function firstArrivalLines(task, roots) {

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

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

package/src/registry/cores.json

@@ -31,7 +31,7 @@
       "name": "deepseek-harness",
       "flag": "--deepseek-harness",
       "package": "@skyf0xx/hedgehog-core-deepseek-harness",
-      "version": "^0.1.0",
+      "version": ">=0.1.0 <1.0.0",
       "language": "typescript",
       "repository": "https://github.com/skyf0xx/hedgehog-core-deepseek-harness",
       "selects_when": "The description names building a plugin, tool, hook, or extension for DeepSeek Harness (DSH) — a Cordis-based agent framework — or otherwise extending an existing DSH installation with new capabilities via its plugin/bundle system. Concrete signals: DSH, DeepSeek Harness, Cordis, `defineTool`, `ctx.tools.register`, a `cordis.patch.yml` manifest, or a request to add a tool that a DSH agent can call. This is the core most often confused with authored: authored fits when no shipped core matches and the planner must design a system shape from scratch, but a DSH plugin already has a fixed, battle-tested shape (the six-layer scaffold → logic → wiring → smoke → bundle → join sequence, one plugin per intent) that authored's from-scratch design would only reinvent worse. Route here whenever the target of the work is a DSH plugin, not a general \"no other core fits\" fallback."