sinapse-ai 1.8.0 → 1.9.1

package/.sinapse-ai/git-hooks/lib/staged-secret-scan.js

@@ -0,0 +1,179 @@
+'use strict';
+
+/**
+ * Staged Secret Scan — git pre-commit guard.
+ *
+ * Reads EXCLUSIVELY the staged blob of each changed file (`git show :<path>`),
+ * so only what is actually being committed is measured (the working-tree copy,
+ * which may differ, is never read — no stash dance required).
+ *
+ * Detection is delegated to the shared core (`secret-scanner-core.js`):
+ *   - all 20+ named patterns
+ *   - Shannon-entropy backstop for unnamed high-entropy tokens
+ *   - placeholder allowlist (.env.example values, your-key-here, CHANGEME, …)
+ *   - lockfile-hash context allowlist
+ *   - redacted output (secrets never printed in full)
+ *
+ * fail-CLOSED: if the scanner cannot run (load error, git error mid-scan), the
+ * commit is BLOCKED (exit 1) rather than silently allowed.
+ *
+ * @module bin/utils/staged-secret-scan
+ */
+
+const path = require('path');
+const { execFileSync, execSync } = require('child_process');
+
+let core;
+try {
+  core = require(path.join(__dirname, 'secret-scanner-core.js'));
+} catch (err) {
+  // fail-CLOSED: the scanner itself is broken — refuse to let a commit through
+  // unscanned.
+  process.stderr.write('\nStaged Secret Scan: scanner failed to load — commit blocked (fail-closed).\n');
+  process.stderr.write(String(err && err.message ? err.message : err) + '\n');
+  process.exit(1);
+}
+
+const { scanContent, redactMatch } = core;
+
+const BLOCKED_ENV_FILE_PATTERN = /(^|\/)\.env(\..+)?$/i;
+const SAFE_ENV_FILE_PATTERN = /(^|\/)\.env\.(example|sample|template)$/i;
+
+// Files that legitimately carry secret-shaped strings by design:
+//   - the scanner's own source (named-pattern regexes embed token shapes like
+//     the JWT header), which would otherwise self-trip the entropy backstop;
+//   - any test/spec file (intentional fixtures that prove detection works).
+// These are PATH-exempt so the guard never blocks committing the guard itself
+// or its tests. All production code paths remain fully scanned.
+const SCANNER_SELF_FILES = new Set([
+  'bin/utils/secret-scanner-core.js',
+  'bin/utils/staged-secret-scan.js',
+  '.claude/hooks/secret-scanning.cjs',
+]);
+const TEST_FILE_PATTERN = /(^|\/)(tests?|__tests__)\/|\.(test|spec)\.[cm]?[jt]s$/i;
+
+function isScanExemptPath(filePath) {
+  const norm = String(filePath).replace(/\\/g, '/');
+  return SCANNER_SELF_FILES.has(norm) || TEST_FILE_PATTERN.test(norm);
+}
+
+/**
+ * Back-compat shim: the previous public API exposed { SECRET_PATTERNS,
+ * findSecretMatches }. They now resolve through the shared core so any external
+ * importer keeps working while gaining the hardened detection.
+ */
+const SECRET_PATTERNS = core.NAMED_PATTERNS.map((p) => ({ label: p.name, pattern: p.pattern }));
+
+function findSecretMatches(content, filePath) {
+  return scanContent(content, { filePath: filePath || '' }).map((f) => f.name);
+}
+
+function getStagedFiles() {
+  try {
+    const output = execSync('git diff --cached --name-only --diff-filter=ACMR', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return output ? output.split('\n').filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function isBlockedEnvFile(filePath) {
+  return BLOCKED_ENV_FILE_PATTERN.test(filePath) && !SAFE_ENV_FILE_PATTERN.test(filePath);
+}
+
+function readStagedFile(filePath) {
+  // Throws on failure so the caller can fail-CLOSED instead of scanning "".
+  return execFileSync('git', ['show', `:${filePath}`], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 5 * 1024 * 1024,
+  });
+}
+
+function scanStagedFiles(files) {
+  const findings = [];
+
+  for (const filePath of files) {
+    // A non-safe .env file is blocked outright (its values are real by design).
+    if (isBlockedEnvFile(filePath)) {
+      findings.push({ filePath, reason: 'environment file (use .env.example with placeholders)', redacted: null });
+      continue;
+    }
+
+    // Skip the scanner's own source + any test/spec file (intentional fixtures).
+    if (isScanExemptPath(filePath)) {
+      continue;
+    }
+
+    let content;
+    try {
+      content = readStagedFile(filePath);
+    } catch {
+      // Could not read the staged blob (binary, deleted-then-readded race, etc.)
+      // — skip silently; binary/secret content of unreadable blobs is rare and
+      // the named .env rule above already covers the common dotfile leak.
+      continue;
+    }
+
+    const matches = scanContent(content, { filePath });
+    for (const match of matches) {
+      findings.push({ filePath, reason: match.name, redacted: match.redacted, entropy: match.entropy });
+    }
+  }
+
+  return findings;
+}
+
+function main() {
+  let stagedFiles;
+  let findings;
+  try {
+    stagedFiles = getStagedFiles();
+    if (stagedFiles.length === 0) {
+      process.exit(0);
+    }
+    findings = scanStagedFiles(stagedFiles);
+  } catch (err) {
+    // fail-CLOSED on any unexpected scanner error.
+    console.error('');
+    console.error('Staged Secret Scan: unexpected error — commit blocked (fail-closed).');
+    console.error(String(err && err.message ? err.message : err));
+    console.error('');
+    process.exit(1);
+  }
+
+  if (findings.length === 0) {
+    process.exit(0);
+  }
+
+  console.error('');
+  console.error('Staged Secret Scan: commit blocked.');
+  console.error('');
+  for (const finding of findings) {
+    const sample = finding.redacted ? ` [${finding.redacted}]` : '';
+    const ent = finding.entropy ? ` (entropy ${finding.entropy})` : '';
+    console.error(`- ${finding.filePath}: ${finding.reason}${sample}${ent}`);
+  }
+  console.error('');
+  console.error('Remove the sensitive content before committing.');
+  console.error('Use .env (gitignored) for local dev and .env.example with placeholders for templates.');
+  console.error('');
+  process.exit(1);
+}
+
+module.exports = {
+  SECRET_PATTERNS,
+  findSecretMatches,
+  getStagedFiles,
+  isBlockedEnvFile,
+  isScanExemptPath,
+  scanStagedFiles,
+  redactMatch,
+};
+
+if (require.main === module) {
+  main();
+}

package/.sinapse-ai/git-hooks/lib/staged-sql-guard.js

@@ -0,0 +1,204 @@
+'use strict';
+
+/**
+ * Staged SQL Guard — git pre-commit guard for destructive DDL/DML.
+ *
+ * Ports the DANGEROUS_PATTERNS from `.claude/hooks/sql-governance.py` (which is
+ * IDE-bound: it only fires on Claude Code Bash tool calls) into an IDE-agnostic
+ * Node guard that runs at the git layer. It scans the STAGED blob of every
+ * changed `.sql` / migration-bearing file and BLOCKS the commit (exit 1) if it
+ * finds destructive schema/data operations:
+ *
+ *   - DROP TABLE/VIEW/FUNCTION/TRIGGER/INDEX/SCHEMA/POLICY
+ *   - TRUNCATE
+ *   - DELETE ... (without a WHERE clause)
+ *   - CREATE TABLE ... AS SELECT (disallowed backup pattern)
+ *
+ * Scope decision: this guard targets the genuinely IRREVERSIBLE / data-loss
+ * operations (the same ones a destructive migration would carry). Plain
+ * CREATE/ALTER are intentionally NOT blocked at the git layer — they are the
+ * normal content of forward migrations and blocking them would make every
+ * legitimate schema change require `--no-verify`. The Claude-Code-level
+ * sql-governance.py still gates CREATE/ALTER at authoring time interactively.
+ *
+ * Only `.sql` files and files under a `migrations/` path are scanned, so SQL
+ * embedded in prose/docs or string literals in application code does not trip
+ * the guard. SQL comments (line and block) are stripped before matching.
+ *
+ * fail-CLOSED on scanner error (a broken guard must never silently pass
+ * destructive SQL). fail-OPEN only when there is genuinely nothing to scan.
+ *
+ * @module bin/utils/staged-sql-guard
+ */
+
+const { execFileSync, execSync } = require('child_process');
+
+/**
+ * Destructive patterns. Mirrors the irreversible subset of
+ * sql-governance.py DANGEROUS_PATTERNS. Each entry: [regex, humanLabel].
+ * Regexes are case-insensitive and operate on comment-stripped SQL text.
+ * @constant {Array<[RegExp, string]>}
+ */
+const DANGEROUS_PATTERNS = [
+  // DDL — destructive drops
+  [/\bDROP\s+TABLE\b/i, 'DROP TABLE'],
+  [/\bDROP\s+VIEW\b/i, 'DROP VIEW'],
+  [/\bDROP\s+MATERIALIZED\s+VIEW\b/i, 'DROP MATERIALIZED VIEW'],
+  [/\bDROP\s+FUNCTION\b/i, 'DROP FUNCTION'],
+  [/\bDROP\s+TRIGGER\b/i, 'DROP TRIGGER'],
+  [/\bDROP\s+INDEX\b/i, 'DROP INDEX'],
+  [/\bDROP\s+SCHEMA\b/i, 'DROP SCHEMA'],
+  [/\bDROP\s+POLICY\b/i, 'DROP POLICY'],
+  [/\bDROP\s+DATABASE\b/i, 'DROP DATABASE'],
+  // DML — data loss
+  [/\bTRUNCATE\b/i, 'TRUNCATE'],
+  // DELETE without a WHERE clause (whole-table wipe).
+  [/\bDELETE\s+FROM\s+[^;]*?(?:;|$)(?<!\bWHERE\b[^;]*)/i, 'DELETE without WHERE'],
+  // Disallowed backup pattern (table copy).
+  [/\bCREATE\s+TABLE\b[\s\S]*?\bAS\s+SELECT\b/i, 'CREATE TABLE AS SELECT (backup pattern)'],
+];
+
+const SQL_FILE_PATTERN = /\.sql$/i;
+const MIGRATION_PATH_PATTERN = /(^|\/)migrations?\//i;
+
+/**
+ * Should this path be SQL-scanned?
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+function isSqlScanTarget(filePath) {
+  const norm = String(filePath).replace(/\\/g, '/');
+  return SQL_FILE_PATTERN.test(norm) || MIGRATION_PATH_PATTERN.test(norm);
+}
+
+/**
+ * Strip SQL comments so `-- DROP TABLE foo` (commented out) is ignored.
+ * Removes `--` line comments and `/* ... *\/` block comments.
+ * @param {string} sql
+ * @returns {string}
+ */
+function stripSqlComments(sql) {
+  return String(sql == null ? '' : sql)
+    .replace(/\/\*[\s\S]*?\*\//g, ' ') // block comments
+    .replace(/--[^\n\r]*/g, ' '); // line comments
+}
+
+/**
+ * Detect destructive SQL in a blob. Operates per-statement (split on ';') so a
+ * `DELETE FROM a WHERE x; DELETE FROM b;` correctly flags only the second.
+ * @param {string} content
+ * @returns {string[]} list of human labels for findings (deduped)
+ */
+function detectDangerousSql(content) {
+  const cleaned = stripSqlComments(content);
+  const statements = cleaned.split(';');
+  const found = new Set();
+
+  for (const rawStmt of statements) {
+    const stmt = rawStmt.trim();
+    if (!stmt) continue;
+
+    for (const [pattern, label] of DANGEROUS_PATTERNS) {
+      if (label === 'DELETE without WHERE') {
+        // Per-statement WHERE check: flag a DELETE FROM only when this
+        // statement has no WHERE.
+        if (/\bDELETE\s+FROM\b/i.test(stmt) && !/\bWHERE\b/i.test(stmt)) {
+          found.add(label);
+        }
+        continue;
+      }
+      if (pattern.test(stmt)) {
+        found.add(label);
+      }
+    }
+  }
+
+  return Array.from(found);
+}
+
+function getStagedFiles() {
+  try {
+    const output = execSync('git diff --cached --name-only --diff-filter=ACMR', {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    return output ? output.split('\n').filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+
+function readStagedFile(filePath) {
+  // Throws on failure so the caller can fail-CLOSED instead of scanning "".
+  return execFileSync('git', ['show', `:${filePath}`], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 5 * 1024 * 1024,
+  });
+}
+
+/**
+ * Scan the given staged files for destructive SQL.
+ * @param {string[]} files
+ * @returns {Array<{ filePath: string, reasons: string[] }>}
+ */
+function scanStagedFiles(files) {
+  const findings = [];
+
+  for (const filePath of files) {
+    if (!isSqlScanTarget(filePath)) continue;
+
+    let content;
+    try {
+      content = readStagedFile(filePath);
+    } catch {
+      // Unreadable blob (binary/deleted-readded race) — skip; SQL files are text.
+      continue;
+    }
+
+    const reasons = detectDangerousSql(content);
+    if (reasons.length > 0) {
+      findings.push({ filePath, reasons });
+    }
+  }
+
+  return findings;
+}
+
+function main() {
+  let findings;
+  try {
+    const files = getStagedFiles();
+    if (files.length === 0) process.exit(0);
+    findings = scanStagedFiles(files);
+  } catch (err) {
+    // fail-CLOSED on unexpected scanner error.
+    process.stderr.write('\nStaged SQL Guard: unexpected error — commit blocked (fail-closed).\n');
+    process.stderr.write(String(err && err.message ? err.message : err) + '\n');
+    process.exit(1);
+  }
+
+  if (findings.length === 0) process.exit(0);
+
+  process.stderr.write('\nStaged SQL Guard: commit blocked (destructive SQL detected).\n\n');
+  for (const f of findings) {
+    process.stderr.write(`- ${f.filePath}: ${f.reasons.join(', ')}\n`);
+  }
+  process.stderr.write('\nDestructive schema/data operations must go through a reviewed migration,\n');
+  process.stderr.write('not a raw commit. If this is an intentional, reviewed migration:\n');
+  process.stderr.write('  git commit --no-verify   (framework contributors / reviewed migrations only)\n\n');
+  process.exit(1);
+}
+
+module.exports = {
+  DANGEROUS_PATTERNS,
+  isSqlScanTarget,
+  stripSqlComments,
+  detectDangerousSql,
+  getStagedFiles,
+  scanStagedFiles,
+};
+
+if (require.main === module) {
+  main();
+}

package/.sinapse-ai/git-hooks/post-commit

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+'use strict';
+/* SINAPSE-MANAGED-GIT-HOOK — Auto-generated by SINAPSE git-hooks-installer. Do not edit manually. */
+/* Re-run `sinapse init` (or the greenfield bootstrap) to regenerate. */
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const projectRoot = process.cwd();
+
+// Migrated from .husky/post-commit (non-blocking, best-effort).
+const POST_COMMIT_SCRIPTS = [
+  path.join('.sinapse-ai', 'infrastructure', 'scripts', 'git-hooks', 'post-commit.js'),
+  path.join('.sinapse-ai', 'hooks', 'ids-post-commit.js'),
+];
+
+for (const rel of POST_COMMIT_SCRIPTS) {
+  const abs = path.join(projectRoot, rel);
+  if (!fs.existsSync(abs)) continue;
+  try {
+    spawnSync(process.execPath, [abs], { stdio: 'ignore', cwd: projectRoot });
+  } catch {
+    // Never block on post-commit failures.
+  }
+}
+
+process.exit(0);

package/.sinapse-ai/git-hooks/pre-commit

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+'use strict';
+/* SINAPSE-MANAGED-GIT-HOOK — Auto-generated by SINAPSE git-hooks-installer. Do not edit manually. */
+/* Re-run `sinapse init` (or the greenfield bootstrap) to regenerate. */
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const projectRoot = process.cwd();
+const libDir = path.join(__dirname, 'lib');
+
+// --- 1-3. SINAPSE staged guards (each fail-CLOSED) ---------------------------
+// Order: secret scan, then destructive-SQL guard, then framework-boundary guard.
+// framework-guard self-disables when boundary.frameworkProtection is false.
+const GUARDS = [
+  { file: 'staged-secret-scan.js', label: 'Secret Scan' },
+  { file: 'staged-sql-guard.js',   label: 'SQL Guard' },
+  { file: 'framework-guard.js',    label: 'Framework Boundary' },
+];
+
+for (const guard of GUARDS) {
+  const guardPath = path.join(libDir, guard.file);
+  if (!fs.existsSync(guardPath)) {
+    // A bundled guard vanished — fail-CLOSED rather than skip silently.
+    process.stderr.write('SINAPSE ' + guard.label + ': guard missing at ' + guardPath + ' — blocking commit (fail-closed).\n');
+    process.exit(1);
+  }
+  const res = spawnSync(process.execPath, [guardPath], { stdio: 'inherit', cwd: projectRoot });
+  if (res.error) {
+    process.stderr.write('SINAPSE ' + guard.label + ': guard failed to run — blocking commit (fail-closed).\n');
+    process.stderr.write('  ' + res.error.message + '\n');
+    process.exit(1);
+  }
+  if (typeof res.status === 'number' && res.status !== 0) {
+    // Non-zero from a guard = commit blocked. A clean guard prints its own
+    // reason; a crashed guard (e.g. corrupted lib) does not, so emit an
+    // explicit fail-closed line so the block is never silent.
+    process.stderr.write('SINAPSE ' + guard.label + ': blocking commit (fail-closed, exit ' + res.status + ').\n');
+    process.exit(res.status);
+  }
+}
+
+// --- 4. Chain to a pre-existing hook (husky or backed-up prior hook) --------
+const explicitChain = null;
+const candidates = [];
+if (explicitChain) {
+  candidates.push(path.resolve(projectRoot, explicitChain));
+}
+candidates.push(path.join(projectRoot, '.husky', 'pre-commit'));
+
+const selfPath = __filename;
+for (const candidate of candidates) {
+  if (!candidate || !fs.existsSync(candidate)) continue;
+  if (path.resolve(candidate) === path.resolve(selfPath)) continue; // never recurse into self
+
+  const isJs = candidate.endsWith('.js') || candidate.endsWith('.cjs');
+  const cmd = isJs ? process.execPath : candidate;
+  const args = isJs ? [candidate] : [];
+  const res = spawnSync(cmd, args, { stdio: 'inherit', cwd: projectRoot });
+
+  if (res.error) {
+    // A shell-script hook (.husky uses sh) may not be directly executable via
+    // spawnSync on Windows. Try 'sh' as an interpreter before giving up.
+    if (!isJs) {
+      const shRes = spawnSync('sh', [candidate], { stdio: 'inherit', cwd: projectRoot });
+      if (!shRes.error) {
+        if (typeof shRes.status === 'number' && shRes.status !== 0) process.exit(shRes.status);
+        break;
+      }
+    }
+    process.stderr.write('SINAPSE pre-commit: failed to run chained hook ' + candidate + ': ' + res.error.message + '\n');
+    process.exit(1);
+  }
+  if (typeof res.status === 'number' && res.status !== 0) {
+    process.exit(res.status);
+  }
+  break; // only chain to the first existing prior hook
+}
+
+process.exit(0);

package/.sinapse-ai/git-hooks/pre-push

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+'use strict';
+/* SINAPSE-MANAGED-GIT-HOOK — Auto-generated by SINAPSE git-hooks-installer. Do not edit manually. */
+/* Re-run `sinapse init` (or the greenfield bootstrap) to regenerate. */
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const projectRoot = process.cwd();
+
+// --- 1. Run validate:all (or validate) if the project defines it -----------
+function pickValidateScript() {
+  try {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const scripts = (pkg && pkg.scripts) || {};
+    for (const name of ['validate:all', 'validate']) {
+      if (typeof scripts[name] === 'string' && scripts[name].length > 0) return name;
+    }
+  } catch {
+    // Unreadable package.json — treat as "no validate script" (allow).
+  }
+  return null;
+}
+
+const script = pickValidateScript();
+if (script) {
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  // shell:true on Windows — spawning npm.cmd without it throws EINVAL (CVE-2024-27980 /
+  // Node DEP0190). Args are fixed/literal here, so there is no shell-injection surface.
+  const res = spawnSync(npmCmd, ['run', '--silent', script], {
+    stdio: 'inherit',
+    cwd: projectRoot,
+    shell: process.platform === 'win32',
+  });
+  if (res.error) {
+    process.stderr.write('SINAPSE pre-push: could not run "npm run ' + script + '" — blocking push (fail-closed).\n');
+    process.stderr.write('  ' + res.error.message + '\n');
+    process.stderr.write('  Bypass (emergency only): git push --no-verify\n');
+    process.exit(1);
+  }
+  if (typeof res.status === 'number' && res.status !== 0) {
+    process.stderr.write('\nSINAPSE pre-push: validation failed (see output above). Push blocked.\n');
+    process.stderr.write('  Bypass (emergency only): git push --no-verify\n\n');
+    process.exit(res.status);
+  }
+}
+
+// --- 2. Chain to a pre-existing pre-push hook ------------------------------
+const explicitChain = ".husky\\pre-push";
+const candidates = [];
+if (explicitChain) {
+  candidates.push(path.resolve(projectRoot, explicitChain));
+}
+candidates.push(path.join(projectRoot, '.husky', 'pre-push'));
+
+const selfPath = __filename;
+for (const candidate of candidates) {
+  if (!candidate || !fs.existsSync(candidate)) continue;
+  if (path.resolve(candidate) === path.resolve(selfPath)) continue;
+
+  const isJs = candidate.endsWith('.js') || candidate.endsWith('.cjs');
+  const cmd = isJs ? process.execPath : candidate;
+  const args = isJs ? [candidate] : [];
+  const res = spawnSync(cmd, args, { stdio: 'inherit', cwd: projectRoot });
+  if (res.error) {
+    if (!isJs) {
+      const shRes = spawnSync('sh', [candidate], { stdio: 'inherit', cwd: projectRoot });
+      if (!shRes.error) {
+        if (typeof shRes.status === 'number' && shRes.status !== 0) process.exit(shRes.status);
+        break;
+      }
+    }
+    process.stderr.write('SINAPSE pre-push: failed to run chained hook ' + candidate + ': ' + res.error.message + '\n');
+    process.exit(1);
+  }
+  if (typeof res.status === 'number' && res.status !== 0) process.exit(res.status);
+  break;
+}
+
+process.exit(0);

package/.sinapse-ai/hooks/ids-post-commit.js

@@ -96,17 +96,19 @@ async function main() {
   }
 
   try {
-    const { RegistryUpdater } = require(path.resolve(REPO_ROOT, '.sinapse-ai/core/ids/registry-updater.js'));
-    const updater = new RegistryUpdater();
-    const result = await updater.processChanges(changes);
-
-    if (result.updated > 0) {
-      console.log(`[IDS-Hook] Registry updated: ${result.updated} entities processed.`);
-    }
-
-    if (result.errors.length > 0) {
-      console.warn(`[IDS-Hook] ${result.errors.length} errors during update.`);
-    }
+    // Use the canonical deterministic generator (populate-entity-registry.js),
+    // NOT the incremental RegistryUpdater. The updater emits a divergent schema
+    // (categories-first, dropping the metadata/resolutionRate block) which
+    // flipped the entire ~30k-line registry on every commit — the recurring
+    // drift. populate() is a fixed point: it preserves lastUpdated/lastVerified
+    // when content is unchanged, so an unchanged repo regenerates byte-identical
+    // (zero churn).
+    const { populate } = require(
+      path.resolve(REPO_ROOT, '.sinapse-ai/development/scripts/populate-entity-registry.js'),
+    );
+    const registry = populate();
+    const count = registry && registry.metadata ? registry.metadata.entityCount : 0;
+    console.log(`[IDS-Hook] Registry regenerated (canonical schema, ${count} entities).`);
   } catch (err) {
     // Post-commit hook should NEVER block workflow
     console.error(`[IDS-Hook] Registry update failed (non-blocking): ${err.message}`);

package/.sinapse-ai/hooks/ids-pre-push.js

@@ -105,13 +105,15 @@ async function main() {
   }
 
   try {
-    const { RegistryUpdater } = require(path.resolve(REPO_ROOT, '.sinapse-ai/core/ids/registry-updater.js'));
-    const updater = new RegistryUpdater();
-    const result = await updater.processChanges(changes);
-
-    if (result.updated > 0) {
-      console.log(`[IDS-Hook] Registry synced: ${result.updated} entities updated before push.`);
-    }
+    // Canonical deterministic generator (see ids-post-commit.js for why the
+    // incremental RegistryUpdater is NOT used: it emits a divergent schema that
+    // churned the whole registry). populate() is a fixed point.
+    const { populate } = require(
+      path.resolve(REPO_ROOT, '.sinapse-ai/development/scripts/populate-entity-registry.js'),
+    );
+    const registry = populate();
+    const count = registry && registry.metadata ? registry.metadata.entityCount : 0;
+    console.log(`[IDS-Hook] Registry synced before push (canonical, ${count} entities).`);
   } catch (err) {
     // Pre-push hook should warn but NOT block push
     console.warn(`[IDS-Hook] Registry sync failed (non-blocking): ${err.message}`);