@tekyzinc/gsd-t 5.8.10 → 5.10.10

package/bin/gsd-t.js

@@ -505,6 +505,31 @@ const WORKTREE_HOOK_MARKER = "gsd-t-worktree-guard";
 const WORKTREE_HOOK_COMMAND =
   'bash -c \'[ -f "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-worktree-guard.js" ] && node "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-worktree-guard.js" || true\'';
 
+// ─── M106 Fallback guard (PreToolUse Write|Edit) ────────────────────────────
+// Denies a write that introduces a fallback the user never approved. NO `|| true`
+// here, unlike the worktree guard: if this script is missing, the shell must fail
+// loudly rather than let unchecked writes through. Swallowing its absence is the
+// exact pattern the guard exists to stop.
+const FALLBACK_HOOK_MARKER = "gsd-t-fallback-guard";
+const FALLBACK_HOOK_COMMAND =
+  'node "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-fallback-guard.js"';
+
+// ─── M108 Install self-heal (SessionStart) ──────────────────────────────────
+// Checks the project's tools before any work starts, restores what is missing,
+// and reports what it could not fix. Not a fallback — it repairs the failure
+// and then the session runs correctly, rather than routing around it.
+const INSTALL_HEAL_MARKER = "gsd-t-install-heal";
+const INSTALL_HEAL_COMMAND =
+  'bash -c \'[ -f "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-install-heal.js" ] && node "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-install-heal.js" || true\'';
+
+// ─── M107 Concise hook (Stop) ───────────────────────────────────────────────
+// Sends a long reply to a fresh Claude for a shorter rewrite. Fail-open by
+// design (`|| true`): it governs how a reply READS, never whether it is true,
+// so a broken rewriter must never gag a correct answer.
+const CONCISE_HOOK_MARKER = "gsd-t-concise-hook";
+const CONCISE_HOOK_COMMAND =
+  'bash -c \'[ -f "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-concise-hook.js" ] && node "$(npm root -g)/@tekyzinc/gsd-t/scripts/gsd-t-concise-hook.js" || true\'';
+
 // Append entries to {projectDir}/.gitignore. Each entry added only if absent.
 // Idempotent. Returns true if any entries were added, false otherwise.
 function ensureGitignoreEntries(projectDir, entries) {
@@ -963,6 +988,76 @@ function configureWorktreeGuardHook(settingsPath) {
   return configureWriteEditHook(settingsPath, WORKTREE_HOOK_MARKER, WORKTREE_HOOK_COMMAND, "worktree guard");
 }
 
+// M106 — register the fallback guard on Write|Edit. Same registrar again.
+function configureFallbackGuardHook(settingsPath) {
+  return configureWriteEditHook(settingsPath, FALLBACK_HOOK_MARKER, FALLBACK_HOOK_COMMAND, "fallback guard");
+}
+
+// M107 — register the concise rewriter on Stop. Not a Write|Edit hook, so it
+// uses the Stop registrar below rather than configureWriteEditHook.
+function configureConciseHook(settingsPath) {
+  return configureStopHook(settingsPath, CONCISE_HOOK_MARKER, CONCISE_HOOK_COMMAND, "concise rewrite");
+}
+
+// M108 — register the install self-heal on SessionStart, so a broken install is
+// repaired before any work begins.
+function configureInstallHealHook(settingsPath) {
+  return configureEventHook(settingsPath, "SessionStart", INSTALL_HEAL_MARKER, INSTALL_HEAL_COMMAND, "install self-heal");
+}
+
+// Register a Stop hook by marker. Mirrors configureWriteEditHook exactly, on the
+// Stop event instead of PreToolUse.
+function configureStopHook(settingsPath, marker, command, label) {
+  return configureEventHook(settingsPath, "Stop", marker, command, label);
+}
+
+// Register a hook on any event by marker. One registrar for every event, so a
+// new hook needs no new copy of this logic.
+function configureEventHook(settingsPath, event, marker, command, label) {
+  const targetPath = settingsPath || SETTINGS_JSON;
+  let settings = {};
+  if (fs.existsSync(targetPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(targetPath, "utf8"));
+      if (!settings || typeof settings !== "object") settings = {};
+    } catch {
+      warn(`settings.json has invalid JSON — cannot configure ${label} hook`);
+      return { installed: false, action: "noop" };
+    }
+  }
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks[event])) settings.hooks[event] = [];
+
+  let action = "noop";
+  let found = false;
+  for (const entry of settings.hooks[event]) {
+    if (!entry || !Array.isArray(entry.hooks)) continue;
+    for (const h of entry.hooks) {
+      if (h && typeof h.command === "string" && h.command.includes(marker)) {
+        found = true;
+        if (h.command !== command) { h.command = command; action = "refreshed"; }
+      }
+    }
+  }
+  if (!found) {
+    // The install check goes FIRST on SessionStart, so a broken install is
+    // repaired before anything else tries to use the missing tools.
+    const entry = { matcher: "", hooks: [{ type: "command", command }] };
+    if (event === "SessionStart") settings.hooks[event].unshift(entry);
+    else settings.hooks[event].push(entry);
+    action = "added";
+  }
+  if (action === "noop") return { installed: true, action };
+
+  try {
+    fs.writeFileSync(targetPath, JSON.stringify(settings, null, 2));
+  } catch (e) {
+    warn(`Failed to write settings.json: ${e.message}`);
+    return { installed: false, action: "noop" };
+  }
+  return { installed: true, action };
+}
+
 function configureWriteEditHook(settingsPath, marker, command, label) {
   const targetPath = settingsPath || SETTINGS_JSON;
   let settings = {};
@@ -1533,10 +1628,16 @@ const UTILITY_SCRIPTS = ["gsd-t-tools.js", "gsd-t-statusline.js", "gsd-t-event-w
 
 function installUtilityScripts() {
   ensureDir(SCRIPTS_DIR);
+  const notDelivered = [];
   for (const script of UTILITY_SCRIPTS) {
     const src = path.join(PKG_SCRIPTS, script);
     const dest = path.join(SCRIPTS_DIR, script);
-    if (!fs.existsSync(src)) continue;
+    if (!fs.existsSync(src)) {
+      // Promised but absent from the package. Reported, never skipped quietly —
+      // the same silence let projects run for weeks on a half install.
+      notDelivered.push(script);
+      continue;
+    }
     const srcContent = fs.readFileSync(src, "utf8");
     const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, "utf8") : "";
     if (normalizeEol(srcContent) !== normalizeEol(destContent)) {
@@ -1545,6 +1646,11 @@ function installUtilityScripts() {
       info(`${script} unchanged`);
     }
   }
+  if (notDelivered.length) {
+    warn(`${notDelivered.length} script(s) are named by the installer but absent from the package:`);
+    for (const s of notDelivered) warn(`    ${s}`);
+    warn(`  Anything depending on these will fail. This is a packaging defect.`);
+  }
 }
 
 // ─── Global Bin Tools (~/.claude/bin/) ───────────────────────────────────────
@@ -1591,6 +1697,21 @@ const GLOBAL_BIN_TOOLS = [
   // caller but absent from BOTH lists is dead in every project
   // ([[project_global_bin_propagation_gap]], 4 prior occurrences).
   "gsd-t-pseudocode-style.cjs",
+  // M106 — Fallback detector. scripts/gsd-t-fallback-guard.js (a PreToolUse hook)
+  // shells out to this by absolute path; if it is missing the guard DENIES the
+  // write rather than allowing it unchecked, so an omission here breaks every
+  // Write/Edit rather than failing silently. Also in PROJECT_BIN_TOOLS below.
+  "gsd-t-fallback-detect.cjs",
+  // M107 — Concise rewriter. scripts/gsd-t-concise-hook.js (a Stop hook) shells
+  // out to this; absent, the hook allows the long reply through (fail-open by
+  // design — it governs readability, never truth).
+  "gsd-t-concise-rewrite.cjs",
+  // M108 — Install self-check, run by the SessionStart hook and by
+  // `gsd-t install-check`.
+  "gsd-t-install-check.cjs",
+  // M109 — project-history reader + rule miner, used by /gsd-t-setup to write a
+  // project CLAUDE.md from what actually happened rather than from a template.
+  "gsd-t-project-history.cjs", "gsd-t-rule-mine.cjs",
 ];
 
 function installGlobalBinTools() {
@@ -1838,10 +1959,14 @@ const SHARED_TEMPLATES = [
 function installSharedTemplates() {
   ensureDir(CLAUDE_TEMPLATES_DIR);
   let installed = 0, skipped = 0;
+  const notDelivered = [];
   for (const file of SHARED_TEMPLATES) {
     const src = path.join(PKG_TEMPLATES, file);
     const dest = path.join(CLAUDE_TEMPLATES_DIR, file);
-    if (!fs.existsSync(src)) continue;
+    if (!fs.existsSync(src)) {
+      notDelivered.push(file); // promised but absent — reported, never silent
+      continue;
+    }
     if (fs.existsSync(dest) &&
         normalizeEol(fs.readFileSync(src, "utf8")) === normalizeEol(fs.readFileSync(dest, "utf8"))) {
       skipped++;
@@ -1852,6 +1977,10 @@ function installSharedTemplates() {
   }
   if (skipped > 0) info(`${skipped} templates unchanged`);
   success(`${installed + skipped} shared templates → ~/.claude/templates/`);
+  if (notDelivered.length) {
+    warn(`${notDelivered.length} template(s) are named by the installer but absent from the package:`);
+    for (const f of notDelivered) warn(`    ${f}`);
+  }
 }
 
 function installCommands(isUpdate) {
@@ -2035,6 +2164,27 @@ async function doInstall(opts = {}) {
     else info("Worktree-collision guard already configured");
   }
 
+  const fbHook = configureFallbackGuardHook(SETTINGS_JSON);
+  if (fbHook.installed) {
+    if (fbHook.action === "added") success("Fallback guard added (denies a write that adds an unapproved fallback — M106)");
+    else if (fbHook.action === "refreshed") success("Fallback guard refreshed");
+    else info("Fallback guard already configured");
+  }
+
+  const ccHook = configureConciseHook(SETTINGS_JSON);
+  if (ccHook.installed) {
+    if (ccHook.action === "added") success("Concise-rewrite hook added (shortens a long reply before you read it — M107)");
+    else if (ccHook.action === "refreshed") success("Concise-rewrite hook refreshed");
+    else info("Concise-rewrite hook already configured");
+  }
+
+  const healHook = configureInstallHealHook(SETTINGS_JSON);
+  if (healHook.installed) {
+    if (healHook.action === "added") success("Install self-heal added (restores missing tools before work starts — M108)");
+    else if (healHook.action === "refreshed") success("Install self-heal refreshed");
+    else info("Install self-heal already configured");
+  }
+
   heading("Graph Engine (CGC)");
   installCgc();
 
@@ -2993,6 +3143,19 @@ const PROJECT_BIN_TOOLS = [
   "gsd-t-model-tier-policy.cjs",
   // M86 — Model-profile config + resolver CLI (standard/pro/premium tier-spend switch).
   "gsd-t-model-profile.cjs",
+  // M106 — Fallback detector. The PreToolUse guard prefers the project-local
+  // copy; the verify gate dispatches to it by absolute path. Missing here means
+  // every Write/Edit is DENIED (the guard halts rather than allowing unchecked),
+  // so this entry is load-bearing — [[project_global_bin_propagation_gap]].
+  "gsd-t-fallback-detect.cjs",
+  // M107 — Concise rewriter, invoked by the Stop hook.
+  "gsd-t-concise-rewrite.cjs",
+  // M108 — Install self-check. Every project carries its own copy so it can
+  // verify and repair itself even when the global install is what broke.
+  "gsd-t-install-check.cjs",
+  // M109 — project-history reader + rule miner, so /gsd-t-setup can write a
+  // project CLAUDE.md from what actually happened rather than from a template.
+  "gsd-t-project-history.cjs", "gsd-t-rule-mine.cjs",
   // M89 — Auto-research gate classifier (classify a guessed claim as internal vs external;
   // propagated to each registered project's bin/ so the workflow runCli fallback resolves
   // downstream — per [[project_global_bin_propagation_gap]]).
@@ -3157,10 +3320,20 @@ function copyBinToolsToProject(projectDir, projectName) {
     }
   }
   let copied = 0;
+  // Tools this pass could NOT deliver. Every one is reported. A silent skip
+  // here is how binvoice ran for weeks with 20 of 38 tools while every update
+  // reported success — the missing files were never counted, so nothing looked
+  // wrong. ([[project_global_bin_propagation_gap]], now 5 occurrences.)
+  const notDelivered = [];
   for (const tool of PROJECT_BIN_TOOLS) {
     const src = path.join(PKG_ROOT, "bin", tool);
     const dest = path.join(projectBinDir, tool);
-    if (!fs.existsSync(src)) continue;
+    if (!fs.existsSync(src)) {
+      // The package promises a tool it does not contain. That is a packaging
+      // defect and it affects EVERY project — it must never pass unremarked.
+      notDelivered.push({ tool, why: "absent from the package being installed" });
+      continue;
+    }
     let needsCopy = true;
     if (fs.existsSync(dest)) {
       try {
@@ -3168,7 +3341,7 @@ function copyBinToolsToProject(projectDir, projectName) {
         const destContent = fs.readFileSync(dest, "utf8");
         if (srcContent === destContent) needsCopy = false;
       } catch {
-        // fall through, will copy
+        // could not compare — copy, which is the safe direction
       }
     }
     if (needsCopy) {
@@ -3177,10 +3350,17 @@ function copyBinToolsToProject(projectDir, projectName) {
         try { fs.chmodSync(dest, 0o755); } catch {}
         copied++;
       } catch (e) {
-        warn(`${projectName} — failed to copy ${tool}: ${e.message}`);
+        notDelivered.push({ tool, why: e.message });
       }
     }
   }
+  if (notDelivered.length) {
+    warn(`${projectName} — ${notDelivered.length} of ${PROJECT_BIN_TOOLS.length} tools were NOT delivered:`);
+    for (const n of notDelivered) warn(`    ${n.tool} — ${n.why}`);
+    warn(`  This project's install is incomplete. Tools that depend on the missing`);
+    warn(`  files will fail. Run 'gsd-t install-check --project ${projectDir}' after`);
+    warn(`  fixing the package.`);
+  }
   let cleaned = 0;
   if (!_isGsdTSourcePackage(projectDir)) {
     for (const stray of DEPRECATED_BIN_STRAYS) {
@@ -5369,6 +5549,20 @@ if (require.main === module) {
       });
       process.exit(res.status == null ? 1 : res.status);
     }
+    case "install-check": {
+      // M108 — check this project's tools against the installed package, and
+      // restore anything missing. `--check` reports without changing anything;
+      // `--report` reads the shared log of every repair across all projects.
+      const { spawnSync } = require("child_process");
+      const js = path.join(__dirname, "gsd-t-install-check.cjs");
+      if (!require("node:fs").existsSync(js)) {
+        error(`gsd-t-install-check.cjs not found at ${js} — reinstall GSD-T`);
+        process.exit(1);
+      }
+      const res = spawnSync(process.execPath, [js, ...args.slice(1)], { stdio: "inherit" });
+      process.exit(res.status == null ? 1 : res.status);
+    }
+
     case "pseudocode-style": {
       // Contract v1.2.0 §1.1 — `gsd-t pseudocode-style (--doc <f> | --dir <d>)` thin
       // dispatcher to the PseudoCode flow-line STYLE gate. Sibling of `guard-map`:

package/commands/gsd-t-setup.md

@@ -72,109 +72,133 @@ CLAUDE.md Analysis:
 
 Note: "No existing CLAUDE.md — will generate from scratch."
 
-## Step 4: Ask Targeted Questions
+## Step 3.5: Read what actually happened here
 
-Only ask what could NOT be auto-detected. Skip questions where the answer is already clear from scanning.
+Before writing anything, read the project's own history. A rule that keeps
+getting broken is the rule that most needs writing down, and nobody remembers
+those on request — they have to be found.
 
-**Potential questions** (ask only if not auto-detected):
+```bash
+node bin/gsd-t-project-history.cjs --project . --json
+```
 
-1. **Branch Guard**: "Which branch should commits target?" (skip if only `main` or `master` exists)
-2. **Autonomy Level**: "What autonomy level? Level 1 (Supervised), Level 2 (Standard), Level 3 (Full Auto — default)" (skip if existing CLAUDE.md already declares it)
-3. **Workflow Preferences**: "Any overrides to the global defaults? (Research Policy, Phase Flow)" (skip if user has no overrides)
-4. **Deployed URLs**: "Production, staging, and local URLs?" (skip if found in .env or existing docs)
-5. **Project-specific rules**: "Any 'never do' rules specific to this project?" (skip if existing CLAUDE.md already has them)
+Three sources, cheapest first. Each reports whether it was there; a missing one
+is **named**, never skipped in silence:
 
-**Do NOT ask about**:
-- Tech stack (auto-detected)
-- Naming conventions (auto-detected)
-- Testing framework (auto-detected)
-- File structure (auto-detected)
-- Anything already covered by the global CLAUDE.md
+| Source | What it gives |
+|---|---|
+| Git | Files fixed the same way repeatedly, and real reverts |
+| Decision log | Directives already recorded, with dates |
+| Past sessions | What the user typed when something kept going wrong |
 
-## Step 5: Generate CLAUDE.md
+Session history is large — one project holds 315 MB — so the tool funnels it:
+keep only the user's own turns, drop pasted logs, keep only complaint-shaped
+lines. Under a second, and the result fits in context.
 
-Build the file using this structure. Include only sections that have real content — omit empty sections entirely.
+**If it exits 4, there is no history at all.** Do not carry on and write a
+thinner file. Stop and ask:
 
-```markdown
-# {Project Name}
+```
+Sources found: git 67 commits | decision log 1 line | sessions 0 | contracts 0
+
+I can mine 0 rules from this project's history.
+
+  a) Write stack and commands only — the rules section left out, with the
+     reason written into the file. Not a normal CLAUDE.md.
+  b) You dictate the rules now.
+  c) Stop.
+```
+
+Whichever they pick, the gap goes **into the generated file** — "Rules: none
+derivable, no project history" — so thinness stays visible rather than reading
+as "this project has no rules."
 
-## Branch Guard
-**Expected branch**: {branch}
+## Step 4: Show the rules found, and let the user tick them
 
-## Project Overview
-{Brief description — what problem does this solve and for whom?}
+Do **not** ask the user to recall rules. Mine every rule the project already
+states, and let them confirm:
 
-### Architecture
-{High-level architecture summary if the project has one — e.g., "Three-tier WebSocket bridge" with a diagram. Keep it concise. Details belong in docs/architecture.md}
+```bash
+node bin/gsd-t-rule-mine.cjs --project . --top 12
+```
+
+Six sources, ranked by how many agree — a rule found in three places ranks top,
+because repetition is the evidence. The output is a tick-list:
+
+```
+12 candidate rules for binvoice. Tick the ones that must NEVER be broken.
 
-## Where Things Live
+     RULE                                                    SEEN IN
+ 1 [ ] NEVER contact the buyer directly                      CLAUDE.md (HC-003)
+ 2 [ ] TEXT-FIRST capture (enforced by a pre-write gate)     CLAUDE.md (HC-004)
+ 3 [ ] NEVER scan the whole page                             CLAUDE.md (HC-005)
 
-| Need to find... | Look here |
-|-----------------|-----------|
-| {component} | {path} |
+Tick numbers (e.g. 1,3,4) or 'all':
+```
 
-## Key Technologies
-{Bulleted list of language, framework, database, testing, etc.}
+The right-hand column is what makes this fast — the user is confirming
+something they already said, not recalling it. **Cap the screen at 12.**
+Anything below goes to `.gsd-t/setup-rules-full.md`; nothing is dropped.
 
-## Documentation
-- Requirements: docs/requirements.md
-- Architecture: docs/architecture.md
-- Workflows: docs/workflows.md
-- Infrastructure: docs/infrastructure.md
+**Never invent a rule.** Every one comes from somewhere in the project, and the
+tick-list shows where. A rule the user did not tick is not inviolable — it may
+still belong elsewhere in the file, but not in that section.
 
-## Autonomy Level
-**Level {N} — {Name}** ({description})  <!-- default: Level 3 — Full Auto -->
+**Determine these by reading, never by asking:**
 
-## Workflow Preferences
-<!-- Override global defaults. Delete what you don't need to override. -->
+| | How |
+|---|---|
+| Which branch | `git branch --show-current` |
+| Where the repo misleads | Two version fields disagreeing, a legacy path that still looks live |
+| Which files are dangerous | Fixed 5+ times in the git history |
+| Stack, build, test | The manifest |
 
-### Research Policy
-{project-specific overrides, or omit section}
+**Ask only if genuinely unresolvable:** the autonomy level when no existing
+CLAUDE.md declares one, and deployed URLs when nothing records them.
 
-### Phase Flow
-{project-specific overrides, or omit section}
+## Step 5: Generate CLAUDE.md
 
-## Testing
-{Framework, file organization, naming, running instructions}
+Use the mold at `templates/CLAUDE-project.md`. It is a real mold — do NOT copy
+any existing project's file, and never GSD-T's own.
 
-## Code Patterns to Follow
-{Project-specific conventions that differ from or extend global defaults}
+**Every section may be left out, with the reason stated. None may be padded.**
 
-### Naming Conventions
-{If different from global defaults}
+| Section | Include when | Fill from |
+|---|---|---|
+| Title + one-line what-this-is | Always | The manifest, the README |
+| **Rules that can never be broken** | The user ticked at least one | Step 4's tick-list, verbatim |
+| Where the repo misleads you | Reading the code gives a confident wrong answer | Determined, never asked |
+| Files riskier than they look | Some file was fixed 5+ times | Git history |
+| Where this differs from global | A genuine difference exists | Compared against `~/.claude/CLAUDE.md` |
+| Stack and commands | Always | The manifest |
+| Where things are written down | Always | Fixed pointers |
 
-## Running the App
-{Dev server, build commands, first-time setup}
+**Target 40–70 lines.** If it is longer, something in it is either restating a
+global rule or repeating what the repo already says.
 
-## Environment Variables
-| Variable | Purpose | Default |
-|----------|---------|---------|
-| {VAR} | {purpose} | {default} |
+### What must never appear
 
-## Deployed URLs
-- **Production**: {url}
-- **Staging**: {url}
-- **Local**: http://localhost:{port}
+| Never | Why |
+|---|---|
+| Anything the global file already says | Three projects each paste the entire Destructive Action Guard verbatim — 15 wasted lines apiece |
+| Anything a hook or gate enforces | The machine does not read this file |
+| A version number, a line count, "currently in progress" | Wrong within a week. It belongs in `progress.md` |
+| A file listing, a dependency list, a command count | The repo answers it, and answers it currently |
+| A rule nobody stated | Every rule comes from the tick-list, and the tick-list shows its source |
 
-## Don't Do These Things
-{Project-specific rules only — don't repeat global rules}
+### The line that matters most
 
-## GSD-T Workflow
-This project uses contract-driven development.
-- State: .gsd-t/progress.md
-- Contracts: .gsd-t/contracts/
-- Domains: .gsd-t/domains/
+A rule states **what must never happen and what breaks if it does**. If it is
+enforced by a hook or a gate, say so — the reader should know a machine is
+watching:
 
-## Current Status
-See `.gsd-t/progress.md` for current milestone/phase state.
+```
+- **Never touch facebook.com** — no permissions, no requests, no DOM writes.
+  A single write turns a read-only observer into an actor on someone else's
+  account. Enforced by a pre-write gate.
 ```
 
-### Section Rules:
-- **NEVER duplicate** global CLAUDE.md content (Destructive Action Guard, Pre-Commit Gate, Prime Directives, etc.)
-- **ALWAYS include**: Branch Guard, GSD-T Workflow, Current Status
-- **Include if relevant**: Where Things Live, Testing, Code Patterns, Environment Variables
-- **Omit if empty**: Deployed URLs (if not deployed), Architecture (if trivial), Workflow Preferences (if no overrides)
-
+Not: *"Be careful with Facebook interactions."*
 ## Step 5.5: Quality North Star Configuration
 
 After generating the CLAUDE.md content (Step 5) and before presenting it to the user, offer a Quality North Star section if one is not already present.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.8.10",
+  "version": "5.10.10",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",