@tekyzinc/gsd-t 5.2.11 → 5.4.10

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.4.10] - 2026-07-27
+
+### Added — Integer-identity primary keys + case-insensitive domain comparisons (two framework-wide code standards)
+
+Two mandatory standards, both previously absent from GSD-T. **(1) Every NEW relational table gets a self-incrementing integer primary key named `id`**; API-exposed tables also get a separate UNIQUE `public_id` UUID. The integer wins inside the database (8 bytes vs 16, insert-ordered so the index stays compact, fast joins, readable in logs); the UUID protects the edge (a sequential id in a URL leaks row counts and lets anyone enumerate `/invoice/1`, `/invoice/2`). `postgresql.md` previously said the opposite — "UUID preferred over serial" — with a UUID GOOD example agents were copying. **(2) Comparing a domain string value against a literal is case-insensitive by default** (status, filter, tab, role, category, email, user-entered text), while identifiers, secrets, hashes, encoded values, Linux file paths, object keys, and env-var names stay case-sensitive — blanket insensitivity on a token or hash is a security defect. Origin: a real shipped bug where `filter !== 'Invoiced'` never matched a lowercase `'invoiced'`, producing two visible UI defects from one casing mismatch.
+
+**Scope — NEW tables only.** A survey of all 32 registered projects found ~480 existing tables on UUID/cuid primary keys whose foreign keys already point at those UUIDs; changing an established primary key is a data migration and a Destructive Action Guard item, not an in-passing edit. No distributed-writes escape hatch was added — the same survey found zero multi-node or offline-first writers, so an unused exception path would be a speculative branch.
+
+**Firestore and Neo4j are exempt, and the exemption is stated rather than silent.** Firestore has no sequence to increment — forcing one means a counter document that serializes every write in the collection, re-introducing the bottleneck the database exists to avoid. Neo4j has no rows, and its internal `id()` is reused after node deletion. Leaving those files silent would let an agent read the gap as an oversight and invent the counter-document anti-pattern.
+
+- `bin/gsd-t-schema-id-check.cjs`: NEW deterministic verify gate (`schema-id`), FAIL-CLOSED. Inspects only schema files new or modified in the working tree, so established UUID-keyed repos pass untouched. Explicit no-op PASS (distinguishable from a wired-but-broken FAIL) when git is unavailable or no schema files changed.
+- `bin/gsd-t-verify-gate.cjs`: wired `schema-id` into the Track 2 default plan.
+- `templates/stacks/_comparison.md`: NEW universal rules file (`_` prefix → auto-injected into every project regardless of stack). Case-insensitive/case-sensitive split, SQL guidance with functional-index note, shared-constant rule, verification checklist.
+- `templates/stacks/postgresql.md`: §1 naming + §2 schema design rewritten; GOOD/BAD examples and checklist updated; explicit scope note on non-retrofit.
+- `templates/stacks/prisma.md`: `id Int @id @default(autoincrement())` mandatory + `publicId`; GOOD/BAD examples inverted (the old BAD example was the new rule).
+- `templates/stacks/supabase.md`: NEW §6.5 — including that a `user_id` column referencing `auth.users` stays UUID because row-level security compares it against `auth.uid()`.
+- `templates/stacks/firebase.md`, `templates/stacks/neo4j.md`: stated exemptions with the counter-document anti-pattern shown as BAD.
+- `templates/stacks/typescript.md`: §6 extended — a fixed value set lives in ONE shared constant so the compiler catches mismatches (case-insensitivity only treats the symptom; a typo'd value still fails silently).
+- `templates/CLAUDE-global.md` + live `~/.claude/CLAUDE.md`: both rules added and kept in sync, so they govern conversational work as well as spawned domain workers.
+- `test/schema-id-check.test.js`: NEW — 11 regression tests covering all three Postgres identity spellings, UUID/text/composite rejection, nested-paren bodies, Prisma models, and the new-tables-only scope.
+
+Migration: none required. Existing schemas are unaffected — the gate ignores committed tables, and no existing project is retrofitted.
+
+## [5.3.10] - 2026-07-24
+
+### Changed — Fable 5 removed; Opus tier upgraded to Opus 5 (claude-opus-5)
+
+The 4-tier model map (haiku/sonnet/opus/fable) collapses to **3 tiers (haiku/sonnet/opus)** where `opus` = **`claude-opus-5`**. Opus 5 shipped 2026-07-24 at the SAME price as Opus 4.8 ($5/$25 per M tokens) but >2× its coding score (Frontier-Bench) and within 0.5% of Fable 5 at max effort — so Fable's cost premium ($10/$50, double Opus 5) is no longer justified. **Every stage formerly on Fable OR Opus 4.8 now runs Opus 5.** Opus 5's context window is 1M tokens (same as 4.8 — no large-context regression), knowledge cutoff May 2026.
+
+The M82 competition judge-blindness invariant is **RELAXED** from "judge model ≠ producers model" to "judge runs in a fresh independent context" — producers AND judge both run Opus 5 (fresh contexts remove memory-bias; the modest residual taste/blind-spot bias is accepted for a stronger judge). The judge≠producers clamp is removed from the tier policy, the profile resolver, and the drift lint.
+
+- `bin/gsd-t-model-tier-policy.cjs`: MODEL_IDS `opus`→`claude-opus-5`, `fable` DELETED; all 7 STAGE_TIERS → opus; `requiresThinkingOmitted` now a single-home no-op (no model requires omission post-Fable); judge blindness clamp removed.
+- `bin/gsd-t-model-profile.cjs`: 3 profiles remapped to dial OPUS-vs-SONNET (standard=probes-opus/rest-sonnet, pro=mid, premium=all-opus); blindness clamp removed.
+- `bin/gsd-t-parallel.cjs`: fable alias removed.
+- `templates/workflows/*.workflow.js` (5): every `model: "fable"` / `?? "fable"` → `"opus"`.
+- `templates/prompts/{blind-adversary,research}-subagent.md`: model annotation fable → opus.
+- Drift-enforcer lints (`test/m85-*`, `test/m86-*`, `test/m90-tier-policy-lint`) updated atomically with the policy — fable fixtures/expectations → opus/sonnet; the "cycles must differ" + "judge≠producers" assertions removed.
+- Contracts: `model-tier-policy-contract.md` v2.0.0 (BREAKING), `model-profile-config-contract.md` v1.1.0 — each with a Fable-removed banner.
+- `templates/CLAUDE-global.md` + live `~/.claude/CLAUDE.md`: Model Display doctrine updated.
+- Command files (`gsd-t-help/status/debug/partition`), README, GSD-T-README updated.
+
+Full suite: 3019/3019 pass, 13 skipped. Zero executable `fable` literal remains in bin/workflows/lints; producers AND judge both resolve to `claude-opus-5`; all 3 profiles resolve with no fable.
+
 ## [5.2.11] - 2026-07-22
 
 ### Changed — architect-overview cleanup (dead tool, shared reader, archived contracts)

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.2.11** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.4.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.
@@ -18,7 +18,7 @@
 **Rigorous User-Journey Coverage + Anti-Drift Test Quality** — `bin/journey-coverage.cjs` regex listener detector + `gsd-t check-coverage` CLI + `scripts/hooks/pre-commit-journey-coverage` commit gate blocks viewer-source commits when uncovered listeners exist. Journey specs in `e2e/journeys/` use functional assertions (zero `toBeVisible`-only tests) per the E2E Test Quality Standard in CLAUDE.md.
 **Universal Playwright Bootstrap + Deterministic UI Enforcement (M50)** — three executable enforcement layers: (1) `bin/playwright-bootstrap.cjs` + `bin/ui-detection.cjs` - idempotent installer detects package manager, installs `@playwright/test` + chromium, scaffolds `e2e/`; (2) Workflow runtime runs `playwright-bootstrap.cjs::installPlaywright()` before any E2E stage when `hasUI && !hasPlaywright`; install failure halts with `blocked-needs-human`; (3) `scripts/hooks/pre-commit-playwright-gate` (opt-in via `gsd-t doctor --install-hooks`) blocks viewer-source commits when staged files are newer than `.gsd-t/.last-playwright-pass`. The `gsd-t setup-playwright [path]` subcommand handles manual install.
 **Visualizer (`/gsd-t-visualize`)** — launches a real-time browser dashboard with dual-pane view: top pane streams the main session, bottom pane streams whichever spawn the user clicks. Left rail shows Live Spawns and Completed (last 100 spawns, status-badged, collapsible). Right rail shows Spawn Plan / Parallelism / Tool Cost. Powered by `gsd-t-stream-feed-server.js` + `gsd-t-dashboard.html`.
-**Surgical model selection** — models are assigned haiku/sonnet/opus/fable per phase. **M85 single-source tier policy:** `bin/gsd-t-model-tier-policy.cjs` is the SINGLE source of truth for model-tier assignments; the 5 highest-leverage stages (solution-space probe, partition probe, competition judge, pre-mortem, Red Team) run on `fable` (Claude Fable 5, tier above Opus); competition producers stay `opus` (M82 blindness); debug escalates cycle-1→opus, cycle-2→fable. Drift is mechanically enforced by the M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`). **M86 model profiles:** `bin/gsd-t-model-profile.cjs` adds a per-project SECOND dimension — three named profiles (`standard` / `pro` / `premium`) that control which stages run on Fable vs. Opus/Sonnet (see [Model Profiles](#model-profiles) below).
+**Surgical model selection** — models are assigned haiku/sonnet/opus per phase (**Fable removed 2026-07-24**; `opus` = **claude-opus-5**). **Single-source tier policy:** `bin/gsd-t-model-tier-policy.cjs` is the SINGLE source of truth; every high-stakes stage (solution-space probe, partition probe, competition judge, pre-mortem, Red Team, competition producers, debug both cycles) runs Opus 5. Opus 5 shipped at the same price as Opus 4.8 but >2× its coding score, so Fable's cost premium is no longer justified. The M82 judge-blindness invariant is relaxed to "fresh independent context" — producers and judge both run opus. Drift is mechanically enforced by the M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`). **M86 model profiles:** `bin/gsd-t-model-profile.cjs` adds a per-project SECOND dimension — three named profiles (`standard` / `pro` / `premium`) that dial which stages run on Opus vs. Sonnet.
 **Token Telemetry** — `gsd-t-calibration-hook.js` records token usage per spawn to `.gsd-t/token-metrics.jsonl` (18-field rows). `gsd-t-token-aggregator.js` aggregates across tasks for the `/gsd-t-metrics` view. Use the native Claude Code `/context` command for live in-session context percentage.
 **Quality North Star** — projects define a `## Quality North Star` section in CLAUDE.md (1–3 sentences, e.g., "This is a published npm library. Every public API must be intuitive and backward-compatible."). `gsd-t-init` auto-detects preset (library/web-app/cli) from package.json signals; `gsd-t-setup` configures it for existing projects. Subagents read it as a quality lens; absent = silent skip (backward compatible).
 **Design Brief Artifact** — during partition, UI/frontend projects (React, Vue, Svelte, Flutter, Tailwind) automatically get `.gsd-t/contracts/design-brief.md` with color palette, typography, spacing system, component patterns, and tone/voice. Non-UI projects skip silently. User-customized briefs are preserved. Referenced in plan phase for visual consistency.

package/bin/gsd-t-model-profile.cjs

@@ -51,7 +51,7 @@ const GLOBAL_DEFAULT_PROFILE = 'premium';
 const VALID_PROFILES = Object.keys(PROFILE_STAGE_TIERS); // ['standard','pro','premium']
 
 /** Valid tier names. */
-const VALID_TIERS = Object.keys(MODEL_IDS); // ['opus','fable','sonnet','haiku']
+const VALID_TIERS = Object.keys(MODEL_IDS); // ['opus','sonnet','haiku'] (Fable removed 2026-07-24)
 
 /**
  * Stages that CANNOT be overridden (M82 blindness invariant).
@@ -216,12 +216,10 @@ function validateSetStage(stageKey, tier) {
     };
   }
 
-  if (stageKey === 'competition-judge' && MODEL_IDS[tier] === MODEL_IDS.opus) {
-    return {
-      ok: false,
-      error: `competition-judge cannot be set to "${tier}" (resolves to "${MODEL_IDS[tier]}") — judge model must differ from producers' model (M82 blindness invariant)`,
-    };
-  }
+  // Blindness clamp REMOVED 2026-07-24: the M82 invariant relaxed from "judge
+  // model ≠ producers model" to "judge runs in a fresh independent context", so
+  // competition-judge = opus (= producers' model) is now ALLOWED. Any valid tier
+  // is accepted for the judge.
 
   return { ok: true };
 }
@@ -281,14 +279,9 @@ function buildResolveEnvelope(profile, stageOverrides, specificStage, configErro
     if (r.configError && !envelopeConfigError) envelopeConfigError = r.configError;
   }
 
-  // Verify competition-judge !== producers' model (final assertion)
-  if (overrides['competition-judge'] === MODEL_IDS.opus) {
-    // This should never reach here (resolveProfile clamps it), but defense in depth
-    envelopeConfigError = envelopeConfigError || 'blindness clamp: competition-judge resolved to producers model — using profile fallback';
-    const fallbackR = resolveProfile('competition-judge', { profile, stageOverrides: {} });
-    overrides['competition-judge'] = fallbackR.model;
-    thinkingMap['competition-judge'] = fallbackR.requiresThinkingOmitted;
-  }
+  // Blindness clamp REMOVED 2026-07-24: competition-judge = opus (= producers'
+  // model) is now permitted (invariant relaxed to "fresh independent context").
+  // No rewrite of the judge model.
 
   const result = {
     ok: true,

package/bin/gsd-t-model-tier-policy.cjs

@@ -18,11 +18,16 @@
  * Frozen map: tier alias → concrete model id.
  * Consumers MUST import from here — never re-hardcode these strings.
  *
- * @type {Readonly<{opus: string, fable: string, sonnet: string, haiku: string}>}
+ * THREE tiers (Fable removed 2026-07-24): `opus` is now `claude-opus-5` — the
+ * default top tier. Opus 5 shipped at the SAME price as Opus 4.8 ($5/$25 per M
+ * tokens) but >2× its coding score and within 0.5% of Fable 5 at max effort, so
+ * the Fable cost premium ($10/$50 — double Opus 5) is no longer justified. Every
+ * stage formerly on `fable` OR `opus` (4.8) now runs `opus` = claude-opus-5.
+ *
+ * @type {Readonly<{opus: string, sonnet: string, haiku: string}>}
  */
 const MODEL_IDS = Object.freeze({
-  opus:   'claude-opus-4-8',
-  fable:  'claude-fable-5',
+  opus:   'claude-opus-5',
   sonnet: 'claude-sonnet-4-6',
   haiku:  'claude-haiku-4-5-20251001',
 });
@@ -33,18 +38,23 @@ const MODEL_IDS = Object.freeze({
 
 /**
  * Frozen map: stage key → tier alias.
- * 6 stages → fable; competition-producers held at opus (M82 blindness invariant).
+ * Fable removed 2026-07-24: all 7 stages resolve to `opus` (= claude-opus-5).
+ * The M82 competition judge-blindness invariant is RELAXED from "different model"
+ * to "fresh independent context" — producers AND judge both run Opus 5 (fresh
+ * contexts remove memory-bias; the modest residual taste/blind-spot bias is
+ * accepted for a stronger judge — user-locked 2026-07-24). See
+ * competition-mode-contract.md §Different-context judge.
  *
  * @type {Readonly<Record<string, string>>}
  */
 const STAGE_TIERS = Object.freeze({
-  'solution-space-probe':  'fable',
-  'partition-probe':       'fable',
-  'competition-judge':     'fable',
-  'competition-producers': 'opus',  // HELD — M82 judge-blindness invariant; do NOT move to fable
-  'pre-mortem':            'fable',
-  'red-team':              'fable',
-  'debug-cycle-2':         'fable',
+  'solution-space-probe':  'opus',
+  'partition-probe':       'opus',
+  'competition-judge':     'opus',  // was fable; blindness now via fresh context, not different model
+  'competition-producers': 'opus',
+  'pre-mortem':            'opus',
+  'red-team':              'opus',
+  'debug-cycle-2':         'opus',
 });
 
 // ---------------------------------------------------------------------------
@@ -55,18 +65,22 @@ const STAGE_TIERS = Object.freeze({
  * Returns true IFF the model requires the explicit thinking-disabled parameter
  * to be OMITTED from the API call.
  *
- * Rationale (canonical, single home): `claude-fable-5` returns HTTP 400 when
- * the explicit thinking-disabled parameter is sent. The parameter must therefore
- * be OMITTED for Fable. No other file may re-implement or re-state this predicate.
+ * This predicate existed for `claude-fable-5`, which returned HTTP 400 when the
+ * explicit thinking-disabled parameter was sent. Fable was removed 2026-07-24;
+ * NO current tier model (opus=claude-opus-5, sonnet, haiku) is known to require
+ * omission — Opus 5 and Sonnet 5 default `effort:high` on the API and accept the
+ * thinking params normally. Kept as a single-home predicate (callers still import
+ * it) so a future model that needs omission is added HERE, never re-hardcoded.
  *
  * @param {string} model — concrete model id or tier alias or any string
  * @returns {boolean}
  */
+const MODELS_REQUIRING_THINKING_OMITTED = Object.freeze([]); // none post-Fable
 function requiresThinkingOmitted(model) {
   if (typeof model !== 'string') return false;
-  // Source the id from MODEL_IDS (single-source — no second literal), and accept
-  // the runtime's bracket-suffixed display form (e.g. "claude-fable-5[1m]").
-  return model === MODEL_IDS.fable || model.startsWith(MODEL_IDS.fable + '[');
+  return MODELS_REQUIRING_THINKING_OMITTED.some(
+    (id) => model === id || model.startsWith(id + '[')
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -98,16 +112,15 @@ function resolve(stageKey) {
 /**
  * Frozen profile → stage-key → tier map.
  *
- * Three named profiles:
- *   standard  — ZERO fable (pre-M85 tiers: probes→opus, judge→sonnet,
- *                pre-mortem→opus, red-team→opus, debug both cycles→opus).
- *   pro       — red-team + pre-mortem + debug-cycle-2 → fable; everything
- *                else reverts to standard.
- *   premium   — all 6 M85 fable stages (the full M85 posture).
+ * Fable removed 2026-07-24 — profiles now dial OPUS-vs-SONNET spend (not Fable):
+ *   standard  — cost-leanest: the high-stakes reasoning stages run sonnet,
+ *                only the probes stay opus.
+ *   pro       — mid: red-team + pre-mortem + debug-cycle-2 → opus; the rest sonnet.
+ *   premium   — full opus posture: all 6 designated stages → opus (= claude-opus-5).
  *
- * competition-producers is HELD at opus in ALL profiles (M82 blindness
- * invariant — never fable). It is NOT included here because it is never
- * overridable; the resolver enforces this separately.
+ * competition-producers is held at opus in ALL profiles (always opus-5). The
+ * former judge≠producers blindness clamp is REMOVED — the invariant is now
+ * "fresh independent context," so the judge may equal producers' model.
  *
  * @type {Readonly<Record<string, Readonly<Record<string, string>>>>}
  */
@@ -116,25 +129,25 @@ const PROFILE_STAGE_TIERS = Object.freeze({
     'solution-space-probe': 'opus',
     'partition-probe':      'opus',
     'competition-judge':    'sonnet',
-    'pre-mortem':           'opus',
-    'red-team':             'opus',
-    'debug-cycle-2':        'opus',
+    'pre-mortem':           'sonnet',
+    'red-team':             'sonnet',
+    'debug-cycle-2':        'sonnet',
   }),
   pro: Object.freeze({
     'solution-space-probe': 'opus',
     'partition-probe':      'opus',
     'competition-judge':    'sonnet',
-    'pre-mortem':           'fable',
-    'red-team':             'fable',
-    'debug-cycle-2':        'fable',
+    'pre-mortem':           'opus',
+    'red-team':             'opus',
+    'debug-cycle-2':        'opus',
   }),
   premium: Object.freeze({
-    'solution-space-probe': 'fable',
-    'partition-probe':      'fable',
-    'competition-judge':    'fable',
-    'pre-mortem':           'fable',
-    'red-team':             'fable',
-    'debug-cycle-2':        'fable',
+    'solution-space-probe': 'opus',
+    'partition-probe':      'opus',
+    'competition-judge':    'opus',
+    'pre-mortem':           'opus',
+    'red-team':             'opus',
+    'debug-cycle-2':        'opus',
   }),
 });
 
@@ -148,18 +161,19 @@ const INJECTABLE_STAGES = Object.freeze([
   'debug-cycle-2',
 ]);
 
-/** The HELD producers model id — used by blindness clamps. */
-const PRODUCERS_MODEL_ID = MODEL_IDS.opus; // claude-opus-4-8
+/** The HELD producers model id (always opus = claude-opus-5). */
+const PRODUCERS_MODEL_ID = MODEL_IDS.opus; // claude-opus-5
 
 /**
  * Resolves the concrete model id for a given stage key under a profile,
  * honoring precedence: stageOverrides[stage] ?? profile-tier ?? global-default.
  *
- * Blindness clamps (M82 / pre-mortem c2 #4 — enforced at RESOLVE, not only at
- * write time because the config file is hand-editable):
- *   - competition-producers key in stageOverrides: silently dropped (never in overrides map).
- *   - competition-judge resolved to the producers' model id: BLOCKED — drops the override
- *     and uses the profile tier for competition-judge instead.
+ * Blindness (M82, RELAXED 2026-07-24 to "fresh independent context"):
+ *   - competition-producers key in stageOverrides: still silently dropped (producers
+ *     are always opus — not profile-overridable).
+ *   - competition-judge may now equal the producers' model (both opus) — the old
+ *     judge≠producers clamp is REMOVED; isolation is enforced by fresh context, not
+ *     by a different model.
  *
  * @param {string} stageKey
  * @param {{ profile?: string, stageOverrides?: Record<string,string> }} opts
@@ -222,11 +236,10 @@ function resolveProfile(stageKey, opts) {
       // (Red Team M86 r2 LOW: unknown stage + invalid override resolved fable on standard).
       errors.push(`stageOverrides["${stageKey}"] has invalid tier "${rawOverrideTier}"; falling back to profile tier`);
       resolvedTier = stageKnown ? profileTierMap[stageKey] : 'sonnet';
-    } else if (stageKey === 'competition-judge' && MODEL_IDS[rawOverrideTier] === PRODUCERS_MODEL_ID) {
-      // Blindness clamp: competition-judge must not equal producers' model
-      errors.push(`stageOverrides["competition-judge"] resolves to "${MODEL_IDS[rawOverrideTier]}" (=producers' model); blindness clamp rejected — falling back to profile tier`);
-      resolvedTier = stageKnown ? profileTierMap[stageKey] : 'sonnet';
     } else {
+      // Blindness clamp REMOVED (2026-07-24): competition-judge may equal the
+      // producers' model — isolation is now enforced by fresh context, not a
+      // different model. Any valid tier override is honored.
       resolvedTier = rawOverrideTier;
     }
   } else {

package/bin/gsd-t-parallel.cjs

@@ -610,10 +610,9 @@ function runDispatch(opts) {
   // is sufficient (single-source thesis, AC b).
   const modelAlias = {
     opus:   MODEL_IDS.opus,
-    fable:  MODEL_IDS.fable,
     sonnet: MODEL_IDS.sonnet,
     haiku:  MODEL_IDS.haiku,
-  };
+  }; // fable removed 2026-07-24
   const callerModel = opts && opts.workerModel;
   const workerModel = callerModel === false
     ? null // explicit opt-out: inherit parent's ANTHROPIC_MODEL

package/bin/gsd-t-schema-id-check.cjs

@@ -0,0 +1,246 @@
+"use strict";
+
+// bin/gsd-t-schema-id-check.cjs
+//
+// The deterministic verify-gate lint for the integer-primary-key rule.
+// FAIL-CLOSED for relational schemas; NO-OP PASS for projects with no schema.
+//
+// THE RULE (relational stacks only — postgresql / prisma / supabase / drizzle):
+//   every NEW table has a self-incrementing integer primary key named `id`.
+//
+// SCOPE — NEW tables only. A pre-existing table with a UUID primary key is NOT a
+// failure: its foreign keys already point at that UUID, so changing the PK is a
+// data migration + Destructive Action Guard item, never an in-passing edit. The
+// gate therefore checks only tables whose defining file is UNCOMMITTED or was
+// added in the working tree — i.e. tables this run is introducing. A repo with an
+// established UUID-keyed schema passes untouched.
+//
+// NOT APPLICABLE — firestore/firebase (document store: no sequence to increment;
+// a counter document serializes writes) and neo4j (no rows; internal id() is
+// reused after deletion). Those stacks state the exemption in their own rules
+// file; this gate never inspects them.
+//
+// Zero external npm runtime deps — fs/path/child_process only.
+
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+// ─── SQL: CREATE TABLE detection ─────────────────────────────────────────────
+
+// A table body is scanned for a column that is BOTH an integer type AND carries
+// an identity/serial default AND is the primary key. Postgres spells this three
+// ways; all three are accepted.
+const SQL_IDENTITY_PK =
+  /\bid\b[^,]*?\b(?:bigint|integer|int|smallint)\b[^,]*?\bgenerated\s+(?:always|by\s+default)\s+as\s+identity\b[^,]*?\bprimary\s+key\b/is;
+const SQL_SERIAL_PK = /\bid\b\s+(?:big|small)?serial\b[^,]*?\bprimary\s+key\b/is;
+// Table-level constraint form: id BIGINT GENERATED ... , PRIMARY KEY (id)
+const SQL_IDENTITY_COL =
+  /\bid\b[^,]*?\b(?:bigint|integer|int|smallint)\b[^,]*?\b(?:generated\s+(?:always|by\s+default)\s+as\s+identity|serial)\b/is;
+const SQL_TABLE_PK_ID = /\bprimary\s+key\s*\(\s*"?id"?\s*\)/is;
+
+/**
+ * Extract (tableName, body) for each CREATE TABLE in a SQL string.
+ * Brace-matched on parentheses so nested type parens (numeric(10,2)) don't
+ * truncate the body.
+ */
+function extractSqlTables(sql) {
+  const out = [];
+  const re = /create\s+table\s+(?:if\s+not\s+exists\s+)?([`"\[]?[\w.]+[`"\]]?)\s*\(/gi;
+  let m;
+  while ((m = re.exec(sql)) !== null) {
+    const name = m[1].replace(/[`"\[\]]/g, "");
+    let depth = 1;
+    let i = re.lastIndex;
+    while (i < sql.length && depth > 0) {
+      const ch = sql[i];
+      if (ch === "(") depth++;
+      else if (ch === ")") depth--;
+      i++;
+    }
+    out.push({ name, body: sql.slice(re.lastIndex, i - 1) });
+  }
+  return out;
+}
+
+function sqlTableHasIntegerIdPk(body) {
+  if (SQL_IDENTITY_PK.test(body)) return true;
+  if (SQL_SERIAL_PK.test(body)) return true;
+  if (SQL_IDENTITY_COL.test(body) && SQL_TABLE_PK_ID.test(body)) return true;
+  return false;
+}
+
+// ─── Prisma: model detection ─────────────────────────────────────────────────
+
+const PRISMA_INT_ID = /\bid\s+Int\s+@id\s+@default\s*\(\s*autoincrement\s*\(\s*\)\s*\)/;
+const PRISMA_BIGINT_ID = /\bid\s+BigInt\s+@id\s+@default\s*\(\s*autoincrement\s*\(\s*\)\s*\)/;
+
+/** Extract (modelName, body) for each `model X { ... }` block. */
+function extractPrismaModels(src) {
+  const out = [];
+  const re = /^\s*model\s+(\w+)\s*\{/gm;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    let depth = 1;
+    let i = re.lastIndex;
+    while (i < src.length && depth > 0) {
+      const ch = src[i];
+      if (ch === "{") depth++;
+      else if (ch === "}") depth--;
+      i++;
+    }
+    out.push({ name: m[1], body: src.slice(re.lastIndex, i - 1) });
+  }
+  return out;
+}
+
+function prismaModelHasIntegerIdPk(body) {
+  return PRISMA_INT_ID.test(body) || PRISMA_BIGINT_ID.test(body);
+}
+
+// A Prisma block that is only a relation join table declared with @@id([a, b])
+// still needs its own integer id under the rule — no exemption. But a `view`
+// or `enum` block is not a model and is never reached (regex matches `model`).
+
+// ─── Which files are NEW in this working tree ────────────────────────────────
+
+/**
+ * Files added/modified relative to HEAD, per git. The rule governs NEW tables,
+ * so only these files are inspected.
+ *
+ * Returns null when git is unavailable or the directory is not a repo — the
+ * caller turns that into a NO-OP PASS with an explicit note rather than
+ * silently scanning everything (which would fail every legacy schema).
+ */
+function changedFiles(projectDir) {
+  try {
+    const out = execFileSync(
+      "git",
+      ["status", "--porcelain=v1", "--untracked-files=all"],
+      { cwd: projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const files = [];
+    for (const line of out.split("\n")) {
+      if (!line.trim()) continue;
+      // porcelain v1: XY <path>  (rename: XY <old> -> <new>)
+      const p = line.slice(3).trim();
+      const finalPath = p.includes(" -> ") ? p.split(" -> ").pop() : p;
+      files.push(finalPath.replace(/^"|"$/g, ""));
+    }
+    return files;
+  } catch (_) {
+    return null;
+  }
+}
+
+const SQL_EXT = /\.sql$/i;
+const PRISMA_EXT = /\.prisma$/i;
+
+function isSchemaFile(rel) {
+  if (/node_modules|\.git\//.test(rel)) return false;
+  return SQL_EXT.test(rel) || PRISMA_EXT.test(rel);
+}
+
+function readSafe(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch (_) {
+    return null;
+  }
+}
+
+// ─── Main check ──────────────────────────────────────────────────────────────
+
+function check(projectDir) {
+  const failures = [];
+  const inspected = [];
+
+  const changed = changedFiles(projectDir);
+  if (changed === null) {
+    return {
+      ok: true,
+      check: "schema-id",
+      inspected: [],
+      failures: [],
+      note:
+        "no-op PASS: git unavailable or not a repository — cannot distinguish NEW tables from " +
+        "pre-existing ones, and the rule governs NEW tables only",
+    };
+  }
+
+  const schemaFiles = changed.filter(isSchemaFile);
+  if (schemaFiles.length === 0) {
+    return {
+      ok: true,
+      check: "schema-id",
+      inspected: [],
+      failures: [],
+      note: "no-op PASS: no new or modified .sql/.prisma schema files in the working tree",
+    };
+  }
+
+  for (const rel of schemaFiles) {
+    const abs = path.join(projectDir, rel);
+    const src = readSafe(abs);
+    if (src === null) continue; // deleted file listed by git status
+
+    if (PRISMA_EXT.test(rel)) {
+      for (const model of extractPrismaModels(src)) {
+        inspected.push(`${rel}::model ${model.name}`);
+        if (!prismaModelHasIntegerIdPk(model.body)) {
+          failures.push(
+            `${rel}: model \`${model.name}\` has no self-incrementing integer primary key — ` +
+              `add \`id Int @id @default(autoincrement())\`. If this model is API-exposed, also add ` +
+              `\`publicId String @unique @default(uuid())\` and expose that instead of the integer id.`
+          );
+        }
+      }
+    } else {
+      for (const table of extractSqlTables(src)) {
+        inspected.push(`${rel}::table ${table.name}`);
+        if (!sqlTableHasIntegerIdPk(table.body)) {
+          failures.push(
+            `${rel}: table \`${table.name}\` has no self-incrementing integer primary key — ` +
+              `add \`id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY\`. If this table is ` +
+              `API-exposed, also add \`public_id UUID NOT NULL DEFAULT gen_random_uuid()\` with a ` +
+              `UNIQUE constraint and expose that instead of the integer id.`
+          );
+        }
+      }
+    }
+  }
+
+  return {
+    ok: failures.length === 0,
+    check: "schema-id",
+    inspected,
+    failures,
+    note:
+      inspected.length === 0
+        ? "no-op PASS: changed schema files contain no CREATE TABLE / model definitions"
+        : undefined,
+  };
+}
+
+function parseArgs(argv) {
+  const out = { projectDir: "." };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--project") out.projectDir = argv[++i] || ".";
+  }
+  return out;
+}
+
+module.exports = {
+  check,
+  extractSqlTables,
+  sqlTableHasIntegerIdPk,
+  extractPrismaModels,
+  prismaModelHasIntegerIdPk,
+};
+
+if (require.main === module) {
+  const { projectDir } = parseArgs(process.argv.slice(2));
+  const result = check(projectDir);
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  process.exit(result.ok ? 0 : 1);
+}

package/bin/gsd-t-verify-gate.cjs

@@ -309,6 +309,8 @@ function _detectDefaultTrack2(projectDir, notes) {
 
   plan.push({ id: 'env-registry', cmd: 'node', args: [path.join(__dirname, 'gsd-t-env-registry-check.cjs'), '--project', projectDir], timeoutMs: 30000 }); // M102 D3: no-secret-in-registry + rule-without-table gate, FAIL-CLOSED
 
+  plan.push({ id: 'schema-id', cmd: 'node', args: [path.join(__dirname, 'gsd-t-schema-id-check.cjs'), '--project', projectDir], timeoutMs: 30000 }); // integer-identity PK on every NEW relational table, FAIL-CLOSED (no-op PASS when no new schema files)
+
   // secrets — gitleaks (PATH detection deferred to runtime)
   if (_hasOnPath('gitleaks')) {
     plan.push({

package/commands/gsd-t-debug.md

@@ -62,7 +62,7 @@ Call the `Workflow` tool with:
     symptom: "describe the failing test or runtime error in one sentence",
     projectDir: ".",
     // M86: inject the resolved overrides map so the workflow's ?? form for debug-cycle-2
-    // picks up the profile-tier assignment instead of the premium fable literal.
+    // picks up the profile-tier assignment instead of the premium opus literal.
     // Pass {} when the resolver failed AND you chose the loud-warning path (not halt).
     overrides: { /* ...from resolver result.overrides, or {} on failure */ }
   }