exonous 0.0.0-stage → 2.10.4

package/assets/techne/rules/web/coding-style.md

@@ -0,0 +1,25 @@
+---
+paths:
+  - "**/*.css"
+  - "**/*.scss"
+  - "**/*.sass"
+  - "**/*.less"
+  - "**/*.html"
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+---
+> Builds on the shared rules in `../common/coding-style.md`.
+
+# Web coding style
+
+Group by feature (component folders with colocated styles). Design tokens in CSS variables — spacing, type, color, motion — not scattered literals.
+
+Animate `transform`, `opacity`, `clip-path`; avoid layout properties (`width`, `margin`, `top`, etc.).
+
+Semantic HTML (`header`, `nav`, `main`, `section`) before div soup.
+
+Naming: PascalCase components; `use*` hooks; kebab-case classes; camelCase animation ids.
+
+Deep patterns: load **techne:web** skill on demand.

package/assets/techne/rules/web/design-quality.md

@@ -0,0 +1,21 @@
+---
+paths:
+  - "**/*.css"
+  - "**/*.scss"
+  - "**/*.sass"
+  - "**/*.less"
+  - "**/*.html"
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+---
+> Builds on the shared rules in `../common/patterns.md`.
+
+# Web design quality
+
+Avoid generic template UI. Before coding: pick a deliberate direction (not vague "clean minimal"); define palette and type; gather references; use **ui-design** (`audit`, `harden`) for a11y/finish.
+
+Ship hierarchy, rhythm, states (hover/focus/active), and intentional light/dark when both exist. Skip stock hero + gradient blob defaults and uniform card grids with no POV.
+
+Checklist: not a default component-library clone; believable in a product screenshot; meaningful interaction states.

package/assets/techne/rules/web/hooks.md

@@ -0,0 +1,39 @@
+---
+paths:
+  - "**/*.css"
+  - "**/*.scss"
+  - "**/*.sass"
+  - "**/*.less"
+  - "**/*.html"
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+---
+> Builds on the shared rules in `../common/hooks.md`.
+
+# Web hooks
+
+Wire hooks to the repo package manager (`pnpm`/`yarn`/`npm exec`) — never remote one-off runners.
+
+## PostToolUse (Write|Edit)
+
+1. Format (`prettier --write "$FILE_PATH"`)
+2. Lint (`eslint --fix "$FILE_PATH"`)
+3. Typecheck (project): `timeout 60 pnpm tsc --noEmit --incremental --tsBuildInfoFile node_modules/.cache/tsc-hook.tsbuildinfo`
+
+Without `--incremental` + cache path, rapid edits stack concurrent `tsc` processes. Without `timeout`, hung checks orphan shells.
+
+Optional: `stylelint --fix` on stylesheets.
+
+## PreToolUse
+
+Reject Write tool payloads over ~800 lines — split modules instead.
+
+## Stop
+
+Run production `build` when the session touched bundler config or shared components.
+
+## Controls
+
+`EXONOUS_HOOK_PROFILE`, `EXONOUS_DISABLED_HOOKS`.

package/assets/techne/rules/web/patterns.md

@@ -0,0 +1,23 @@
+---
+paths:
+  - "**/*.css"
+  - "**/*.scss"
+  - "**/*.sass"
+  - "**/*.less"
+  - "**/*.html"
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+---
+> Builds on the shared rules in `../common/patterns.md`.
+
+# Web patterns
+
+Compound components + context for complex widgets. Container/presentational split: data vs pure UI.
+
+State: server cache (TanStack Query/SWR), client store only for UI, URL for filters/tabs/pagination, form library for forms — no duplicated server cache in client stores.
+
+Stale-while-revalidate and optimistic updates with rollback UX. Parallel fetches; avoid request waterfalls.
+
+See **techne:web** for Vite/SEO depth.

package/assets/techne/rules/web/performance.md

@@ -0,0 +1,25 @@
+---
+paths:
+  - "**/*.css"
+  - "**/*.scss"
+  - "**/*.sass"
+  - "**/*.less"
+  - "**/*.html"
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+---
+> Builds on the shared rules in `../common/performance.md`.
+
+# Web performance
+
+Targets: LCP <2.5s, INP <200ms, CLS <0.1. Budgets (~150kb gzip JS landing, ~300kb app — tune per product).
+
+Inline critical CSS when justified; preload hero font/image; defer rest; dynamic-import heavy libs.
+
+Images: dimensions set; lazy below fold; modern formats. Fonts: ≤2 families, `font-display: swap`.
+
+Motion on compositor props only; narrow `will-change`.
+
+Checklist: no layout shift from late content; third parties async/defer.

package/assets/techne/rules/web/security.md

@@ -0,0 +1,23 @@
+---
+paths:
+  - "**/*.css"
+  - "**/*.scss"
+  - "**/*.sass"
+  - "**/*.less"
+  - "**/*.html"
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+---
+> Builds on the shared rules in `../common/security.md`.
+
+# Web security
+
+Production CSP with nonces for scripts where possible; tighten per project. No unsanitized HTML (`innerHTML` / framework escape hatches) without sanitizer.
+
+Third-party scripts: async, SRI on CDNs, periodic audit. Security headers: HSTS, `nosniff`, frame deny, referrer policy, permissions policy.
+
+Forms: CSRF on mutations; server validation; rate limits.
+
+**exo-security** for deep review.

package/assets/techne/rules/web/testing.md

@@ -0,0 +1,21 @@
+---
+paths:
+  - "**/*.css"
+  - "**/*.scss"
+  - "**/*.sass"
+  - "**/*.less"
+  - "**/*.html"
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+---
+> Builds on the shared rules in `../common/testing.md`.
+
+# Web testing
+
+Priority: visual regression at key breakpoints → a11y (keyboard, contrast, reduced motion) → Lighthouse/CWV → cross-browser (Chrome/Firefox/Safari) → responsive widths.
+
+Playwright for E2E/visual; unit tests for utilities/hooks. Deterministic waits, not arbitrary sleeps.
+
+**techne:quality** skill for broader QA patterns.

package/assets/techne/scripts/hooks/config-guard.js

@@ -0,0 +1,50 @@
+// PreToolUse(Write|Edit|MultiEdit): keep agents from loosening lint/format configs to make checks pass.
+// Creating a config that does not exist yet is allowed; editing an existing one is not.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const EXACT = new Set([
+  '.eslintrc', '.eslintignore',
+  '.prettierrc', '.prettierignore',
+  'biome.json', 'biome.jsonc', '.biome.json', '.biome.jsonc',
+  'ruff.toml', '.ruff.toml', '.flake8', '.pylintrc',
+  '.stylelintrc', '.stylelintignore',
+  '.markdownlintrc', '.markdownlintignore',
+  '.shellcheckrc',
+  '.golangci.yml', '.golangci.yaml', '.golangci.toml', '.golangci.json',
+  '.rubocop.yml', '.swiftlint.yml', '.oxlintrc.json',
+]);
+
+const PATTERNS = [
+  // eslint.config.mjs, prettier.config.base.cjs, stylelint.config.shared.ts, …
+  /^(eslint|prettier|stylelint|commitlint|oxlint)\.config(\.[\w-]+)*\.(js|mjs|cjs|ts|mts|cts)$/,
+  // .eslintrc.json, .prettierrc.shared.yml, .stylelintrc.base.cjs, .markdownlint.jsonc, …
+  /^\.(eslintrc|prettierrc|stylelintrc|markdownlintrc|markdownlint|markdownlint-cli2)(\.[\w-]+)*\.(js|mjs|cjs|ts|json|jsonc|yml|yaml|toml)$/,
+];
+
+function isGuarded(file) {
+  const name = path.basename(file).toLowerCase();
+  return EXACT.has(name) || PATTERNS.some((re) => re.test(name));
+}
+
+module.exports = function configGuard(payload, { truncated }) {
+  if (process.env.EXONOUS_ALLOW_CONFIG_EDITS === '1') return null;
+  if (truncated) return { block: 'Hook payload too large to inspect; refusing the edit. Make a smaller edit.' };
+  const input = payload?.tool_input || {};
+  const file = input.file_path || input.path;
+  if (typeof file !== 'string' || !isGuarded(file)) return null;
+
+  const absolute = path.resolve(payload.cwd || process.cwd(), file);
+  try {
+    fs.lstatSync(absolute);
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+  }
+  return {
+    block: `${path.basename(file)} is a lint/format config. Fix the code so it satisfies the rules instead of weakening them. If the user asked for this config change, they can allow it with EXONOUS_ALLOW_CONFIG_EDITS=1.`,
+  };
+};
+
+module.exports.isGuarded = isGuarded;

package/assets/techne/scripts/hooks/edit-tracker.js

@@ -0,0 +1,26 @@
+// PostToolUse(Edit|Write|MultiEdit): remember which files this session touched, for stop:checks.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function listFile(sessionId) {
+  const id = String(sessionId || 'default').replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 128) || 'default';
+  return path.join(os.tmpdir(), `techne-edits-${id}.txt`);
+}
+
+module.exports = function editTracker(payload) {
+  const input = payload?.tool_input || {};
+  const file = input.file_path || input.path;
+  if (typeof file !== 'string' || !file) return null;
+  const absolute = path.resolve(payload.cwd || process.cwd(), file);
+  try {
+    fs.appendFileSync(listFile(payload.session_id), `${absolute}\n`, 'utf8');
+  } catch (err) {
+    process.stderr.write(`[techne] edit list not updated: ${err.message}\n`);
+  }
+  return null;
+};
+
+module.exports.listFile = listFile;

package/assets/techne/scripts/hooks/lib/shell.js

@@ -0,0 +1,204 @@
+// Minimal POSIX-shell lexer for hook guards. It does not evaluate anything; it answers
+// "which simple commands would run, with which words" well enough to spot flags.
+// Output: flat list of { words: string[], heredocs: string[] } — one per simple command,
+// including commands inside $(...), backticks and ( ... ) subshells.
+'use strict';
+
+const SEPARATORS = new Set([';', '&', '|']);
+const WORD_BREAK = /[\s;&|<>()]/;
+
+function lex(src, maxDepth = 8) {
+  const out = [];
+  scan(src, 0, null, out, maxDepth);
+  return out;
+}
+
+function scan(src, start, closer, out, depth) {
+  let segment = { words: [], heredocs: [] };
+  let word = null;
+  let skipNext = false;
+  let pending = [];
+  let i = start;
+
+  const endWord = () => {
+    if (word === null) return;
+    if (skipNext) skipNext = false;
+    else segment.words.push(word);
+    word = null;
+  };
+  const endSegment = () => {
+    endWord();
+    if (segment.words.length || segment.heredocs.length) out.push(segment);
+    segment = { words: [], heredocs: [] };
+  };
+  const nested = (from, close) => {
+    if (depth <= 0) return skipTo(src, from, close);
+    return scan(src, from, close, out, depth - 1);
+  };
+  const readBodies = (from) => {
+    let pos = from;
+    for (const doc of pending) {
+      const lines = [];
+      while (pos < src.length) {
+        const nl = src.indexOf('\n', pos);
+        const line = src.slice(pos, nl === -1 ? src.length : nl);
+        pos = nl === -1 ? src.length : nl + 1;
+        if ((doc.strip ? line.replace(/^\t+/, '') : line) === doc.delim) break;
+        lines.push(line);
+      }
+      doc.segment.heredocs.push(lines.join('\n'));
+    }
+    pending = [];
+    return pos;
+  };
+
+  while (i < src.length) {
+    const c = src[i];
+
+    if (closer && c === closer && closer !== '`') {
+      endSegment();
+      return i + 1;
+    }
+    if (closer === '`' && c === '`') {
+      endSegment();
+      return i + 1;
+    }
+    if (c === '\n') {
+      endSegment();
+      i = pending.length ? readBodies(i + 1) : i + 1;
+      continue;
+    }
+    if (c === ' ' || c === '\t' || c === '\r') {
+      endWord();
+      i++;
+      continue;
+    }
+    if (SEPARATORS.has(c)) {
+      endSegment();
+      i++;
+      continue;
+    }
+    if (c === '#' && word === null) {
+      while (i < src.length && src[i] !== '\n') i++;
+      continue;
+    }
+    if (c === '(' && word === null) {
+      endSegment();
+      i = nested(i + 1, ')');
+      continue;
+    }
+    if (c === '<' || c === '>') {
+      endWord();
+      if (src.startsWith('<<<', i)) {
+        skipNext = true;
+        i += 3;
+        continue;
+      }
+      if (c === '<' && src[i + 1] === '<') {
+        i += 2;
+        const strip = src[i] === '-';
+        if (strip) i++;
+        while (src[i] === ' ' || src[i] === '\t') i++;
+        const delim = readDelimiter(src, i);
+        i = delim.end;
+        pending.push({ delim: delim.text, strip, segment });
+        continue;
+      }
+      i++;
+      while (src[i] === '>' || src[i] === '&' || src[i] === '|') i++;
+      if (/\d/.test(src[i] || '')) {
+        while (/\d/.test(src[i] || '')) i++;
+        if (src[i] === '-') i++;
+        continue;
+      }
+      skipNext = true;
+      continue;
+    }
+    if (c === '\\') {
+      if (src[i + 1] !== '\n') word = (word ?? '') + (src[i + 1] ?? '');
+      i += 2;
+      continue;
+    }
+    if (c === "'") {
+      const end = src.indexOf("'", i + 1);
+      const stop = end === -1 ? src.length : end;
+      word = (word ?? '') + src.slice(i + 1, stop);
+      i = stop + 1;
+      continue;
+    }
+    if (c === '$' && src[i + 1] === "'") {
+      let j = i + 2;
+      let text = '';
+      while (j < src.length && src[j] !== "'") {
+        if (src[j] === '\\' && j + 1 < src.length) j++;
+        text += src[j++];
+      }
+      word = (word ?? '') + text;
+      i = j + 1;
+      continue;
+    }
+    if (c === '"') {
+      word = word ?? '';
+      i++;
+      while (i < src.length && src[i] !== '"') {
+        if (src[i] === '\\' && '"\\$`\n'.includes(src[i + 1])) {
+          if (src[i + 1] !== '\n') word += src[i + 1];
+          i += 2;
+        } else if (src[i] === '$' && src[i + 1] === '(' && src[i + 2] !== '(') {
+          i = nested(i + 2, ')');
+        } else if (src[i] === '`') {
+          i = nested(i + 1, '`');
+        } else {
+          word += src[i++];
+        }
+      }
+      i++;
+      continue;
+    }
+    if (c === '$' && src[i + 1] === '(') {
+      if (src[i + 2] === '(') {
+        i = skipTo(src, i + 3, '))');
+      } else {
+        word = word ?? '';
+        i = nested(i + 2, ')');
+      }
+      continue;
+    }
+    if (c === '`') {
+      word = word ?? '';
+      i = nested(i + 1, '`');
+      continue;
+    }
+    word = (word ?? '') + c;
+    i++;
+  }
+  endSegment();
+  return src.length;
+}
+
+function readDelimiter(src, i) {
+  let text = '';
+  while (i < src.length && !WORD_BREAK.test(src[i])) {
+    const c = src[i];
+    if (c === "'" || c === '"') {
+      const end = src.indexOf(c, i + 1);
+      const stop = end === -1 ? src.length : end;
+      text += src.slice(i + 1, stop);
+      i = stop + 1;
+    } else if (c === '\\') {
+      text += src[i + 1] ?? '';
+      i += 2;
+    } else {
+      text += c;
+      i++;
+    }
+  }
+  return { text, end: i };
+}
+
+function skipTo(src, from, token) {
+  const at = src.indexOf(token, from);
+  return at === -1 ? src.length : at + token.length;
+}
+
+module.exports = { lex };

package/assets/techne/scripts/hooks/no-verify-guard.js

@@ -0,0 +1,205 @@
+// PreToolUse(Bash): refuse git invocations that would skip the repository's git hooks.
+'use strict';
+
+const path = require('path');
+const { lex } = require('./lib/shell');
+
+const HOOK_RUNNING = new Set(['commit', 'push', 'merge', 'cherry-pick', 'rebase', 'am']);
+const SHELLS = new Set(['sh', 'bash', 'dash', 'zsh', 'ksh']);
+const KEYWORDS = new Set(['if', 'then', 'else', 'elif', 'do', 'while', 'until', '!', '{', '}', 'time']);
+const GIT_GLOBALS_WITH_VALUE = new Set(['-C', '--work-tree', '--git-dir', '--namespace', '--super-prefix', '--exec-path']);
+const SUDO_WITH_VALUE = new Set(['-u', '-g', '-h', '-p', '-C', '-D', '-r', '-t', '-U']);
+const ASSIGNMENT = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/s;
+const NO_VERIFY = '--no-verify';
+
+// Long options that consume the next word, per subcommand (values are data, not flags).
+const LONG_WITH_VALUE = {
+  commit: ['--message', '--file', '--reuse-message', '--reedit-message', '--template', '--author', '--date', '--cleanup', '--fixup', '--squash', '--trailer', '--pathspec-from-file'],
+  merge: ['--message', '--file', '--strategy', '--strategy-option', '--into-name'],
+  push: ['--push-option', '--repo', '--receive-pack', '--exec'],
+  rebase: ['--exec', '--strategy', '--strategy-option', '--onto'],
+  'cherry-pick': ['--mainline', '--strategy', '--strategy-option'],
+  am: ['--patch-format', '--directory', '--exclude', '--include', '--resolvemsg'],
+};
+// Short options whose value is the rest of the cluster or the next word.
+const SHORT_WITH_VALUE = {
+  commit: 'mFCct',
+  merge: 'mFsX',
+  push: 'o',
+  rebase: 'xsX',
+  'cherry-pick': 'msX',
+  am: 'pC',
+};
+const SHORT_OPTIONAL_VALUE = { commit: 'uS', merge: 'S', rebase: 'S', 'cherry-pick': 'S', am: 'S' };
+
+const isNoVerify = (word) => word.length >= 9 && NO_VERIFY.startsWith(word);
+const isHooksPathKey = (key) => key.trim().toLowerCase() === 'core.hookspath';
+
+function overridesHooksPath(env) {
+  for (const [name, value] of env) {
+    if (/^GIT_CONFIG_KEY_\d+$/.test(name) && isHooksPathKey(value)) return true;
+    if (name === 'GIT_CONFIG_PARAMETERS' && value.toLowerCase().includes('core.hookspath')) return true;
+  }
+  return false;
+}
+
+// Strips wrappers (env, sudo, command, …) and prefix assignments; returns the real command words.
+function unwrap(words, env) {
+  let i = 0;
+  const take = () => {
+    while (i < words.length) {
+      const m = words[i].match(ASSIGNMENT);
+      if (m) env.set(m[1], m[2]);
+      else if (!KEYWORDS.has(words[i])) break;
+      i++;
+    }
+  };
+  take();
+  for (;;) {
+    const cmd = path.basename(words[i] || '');
+    if (cmd === 'env') {
+      i++;
+      while (i < words.length && (words[i].startsWith('-') || ASSIGNMENT.test(words[i]))) {
+        if (words[i] === '-u' || words[i] === '-S') i++;
+        else if (!words[i].startsWith('-')) {
+          const m = words[i].match(ASSIGNMENT);
+          env.set(m[1], m[2]);
+        }
+        i++;
+      }
+    } else if (cmd === 'sudo' || cmd === 'doas' || cmd === 'nice' || cmd === 'nohup' || cmd === 'command' || cmd === 'exec' || cmd === 'builtin') {
+      i++;
+      while (i < words.length && words[i].startsWith('-')) {
+        if (SUDO_WITH_VALUE.has(words[i]) || (cmd === 'nice' && words[i] === '-n')) i++;
+        i++;
+      }
+    } else break;
+    take();
+  }
+  return words.slice(i);
+}
+
+function checkGit(args, env, scanNested) {
+  let i = 1;
+  let hooksOverride = overridesHooksPath(env);
+  while (i < args.length && args[i].startsWith('-')) {
+    const arg = args[i];
+    if (arg === '-c') {
+      if (isHooksPathKey((args[i + 1] || '').split('=')[0])) hooksOverride = true;
+      i += 2;
+    } else if (arg.startsWith('-c')) {
+      if (isHooksPathKey(arg.slice(2).split('=')[0])) hooksOverride = true;
+      i++;
+    } else if (arg === '--config-env') {
+      if (isHooksPathKey((args[i + 1] || '').split('=')[0])) hooksOverride = true;
+      i += 2;
+    } else if (arg.startsWith('--config-env=')) {
+      if (isHooksPathKey(arg.slice('--config-env='.length).split('=')[0])) hooksOverride = true;
+      i++;
+    } else if (GIT_GLOBALS_WITH_VALUE.has(arg)) {
+      i += 2;
+    } else {
+      i++;
+    }
+  }
+  const sub = args[i];
+  const rest = args.slice(i + 1);
+
+  if (sub === 'config' && setsHooksPath(rest)) {
+    return 'Setting core.hooksPath is not allowed: it disables the repository git hooks.';
+  }
+  if (!HOOK_RUNNING.has(sub)) return null;
+  if (hooksOverride) return `Overriding core.hooksPath on git ${sub} is not allowed: git hooks must run.`;
+
+  const longValue = new Set(LONG_WITH_VALUE[sub]);
+  const shortValue = SHORT_WITH_VALUE[sub] || '';
+  const shortOptional = SHORT_OPTIONAL_VALUE[sub] || '';
+  for (let j = 0; j < rest.length; j++) {
+    const word = rest[j];
+    if (word === '--') break;
+    if (word.startsWith('--')) {
+      const [name, inline] = word.split(/=(.*)/s);
+      if (isNoVerify(name)) return `git ${sub} ${NO_VERIFY} is not allowed: fix what the hook reports instead of skipping it.`;
+      if (longValue.has(name) && inline === undefined) {
+        if (sub === 'rebase' && name === '--exec' && rest[j + 1]) scanNested(rest[j + 1]);
+        j++;
+      } else if (sub === 'rebase' && name === '--exec' && inline) {
+        scanNested(inline);
+      }
+      continue;
+    }
+    if (!/^-[A-Za-z]/.test(word)) continue;
+    for (let k = 1; k < word.length; k++) {
+      const flag = word[k];
+      if (flag === 'n' && sub === 'commit') return 'git commit -n skips the commit hooks and is not allowed.';
+      if (shortOptional.includes(flag)) break;
+      if (shortValue.includes(flag)) {
+        const value = k + 1 < word.length ? word.slice(k + 1) : rest[++j];
+        if (sub === 'rebase' && flag === 'x' && value) scanNested(value);
+        break;
+      }
+    }
+  }
+  return null;
+}
+
+function setsHooksPath(rest) {
+  const positional = [];
+  for (const word of rest) {
+    if (word === '--unset' || word === '--unset-all' || word === '--get' || word === '--get-all' || word === 'unset' || word === 'get') return false;
+    if (!word.startsWith('-')) positional.push(word);
+  }
+  if (positional[0] === 'set') positional.shift();
+  if (!positional.length) return false;
+  const [key, inline] = positional[0].split(/=(.*)/s);
+  return isHooksPathKey(key) && (inline !== undefined || positional.length >= 2);
+}
+
+function inspect(command, depth = 0) {
+  if (depth > 4) return null;
+  const env = new Map();
+  const nestedReasons = [];
+  const scanNested = (script) => {
+    const reason = inspect(script, depth + 1);
+    if (reason) nestedReasons.push(reason);
+  };
+
+  for (const segment of lex(command)) {
+    const local = new Map(env);
+    const words = unwrap(segment.words, local);
+    if (!words.length) {
+      for (const [k, v] of local) env.set(k, v);
+      continue;
+    }
+    const cmd = path.basename(words[0]);
+    if (cmd === 'export') {
+      for (const word of words.slice(1)) {
+        const m = word.match(ASSIGNMENT);
+        if (m) env.set(m[1], m[2]);
+      }
+      continue;
+    }
+    if (cmd === 'git') {
+      const reason = checkGit(words, local, scanNested);
+      if (reason) return reason;
+    } else if (SHELLS.has(cmd)) {
+      const flagIndex = words.findIndex((w, idx) => idx > 0 && /^-[a-zA-Z]*c[a-zA-Z]*$/.test(w));
+      if (flagIndex !== -1 && words[flagIndex + 1]) scanNested(words[flagIndex + 1]);
+      else segment.heredocs.forEach(scanNested);
+    } else if (cmd === 'eval') {
+      scanNested(words.slice(1).join(' '));
+    }
+    if (nestedReasons.length) return nestedReasons[0];
+  }
+  return nestedReasons[0] || null;
+}
+
+module.exports = function noVerifyGuard(payload, { truncated }) {
+  if (truncated) return { block: 'Hook payload too large to inspect; refusing the command. Split it into smaller commands.' };
+  const command = payload?.tool_input?.command;
+  if (typeof command !== 'string' || !/git|GIT_CONFIG/.test(command)) return null;
+  const reason = inspect(command);
+  return reason ? { block: reason } : null;
+};
+
+module.exports.inspect = inspect;