Guards: rules that block instead of asking

  "hooks": {
    "SessionStart": [
      { "hooks": [ { "type": "command",
          "command": "bash \"${CLAUDE_PROJECT_DIR}/.claude/hooks/session-start.sh\"" } ] }
    ],
    "PreToolUse": [
      { "matcher": "Bash",
        "hooks": [ { "type": "command",
          "command": "bash \"${CLAUDE_PROJECT_DIR}/.claude/hooks/destructive-guard.sh\"" } ] }
    ],
    "PostToolUse": [
      { "matcher": "Edit|Write",
        "hooks": [ { "type": "command",
          "command": "bash \"${CLAUDE_PROJECT_DIR}/.claude/hooks/format-on-write.sh\"",
          "timeout": 120 } ] }
    ]
  }

#!/usr/bin/env bash
# PreToolUse guard for Bash: deny commands that rewrite history, destroy data or act on the machine.
# Input: the tool call as JSON on stdin. Output: a deny decision as JSON, or nothing (= normal permission flow).
# No jq needed: we match patterns against the raw JSON text.
input=$(cat)

deny() {
  printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"%s"}}\n' "$1"
  exit 0
}

# Extract the command string for readable matching (falls back to the whole payload).
cmd=$(printf '%s' "$input" | sed -n 's/.*"command"[[:space:]]*:[[:space:]]*"\(\([^"\\]\|\\.\)*\)".*/\1/p')
[ -z "$cmd" ] && cmd=$input

check() { printf '%s' "$cmd" | grep -Eqi -- "$1"; }

check 'git[[:space:]]+push.*(--force|[[:space:]]-f([[:space:]]|$)|--force-with-lease)' && deny "Force-push rewrites shared history. Ask the human; they push, not the agent."
check 'git[[:space:]]+(reset[[:space:]]+--hard|clean[[:space:]]+-[a-z]*f|filter-branch|filter-repo)' && deny "Destroys work or history. Present a 1-3-1 instead."
check 'git[[:space:]]+(rebase|commit[[:space:]].*--amend)' && deny "History rewriting is not allowed (docs/ai/workflow.md). Make a new commit instead."
check 'rm[[:space:]]+-[a-z]*r[a-z]*f|rm[[:space:]]+-[a-z]*f[a-z]*r|Remove-Item.*-Recurse' && deny "Recursive delete blocked. Name the exact files and ask the human."
check 'drop[[:space:]]+(table|database)|dotnet[[:space:]]+ef[[:space:]]+database[[:space:]]+drop|ensuredeleted' && deny "Dropping a database is a human decision. Present a 1-3-1."
check '(Start-Process|open[[:space:]]+-a|systemctl[[:space:]]+start|service[[:space:]]+[a-z-]+[[:space:]]+start|Docker Desktop)' && deny "Starting software on the machine is the human's call (invariants: environment). Ask them to start it."
check '(apt|apt-get|dnf|yum|brew|winget|choco)[[:space:]]+install|dotnet-install' && deny "Installing software is the human's call. Present a 1-3-1."
check 'TargetFramework>net[0-7]\.|net7\.0|net6\.0' && deny "Target framework is net8.0 (AGENTS.md). A missing SDK is a 1-3-1, not a downgrade."

exit 0

#!/usr/bin/env bash
# SessionStart: plain stdout becomes context for the agent. Report the environment, and never fix it.
cd "${CLAUDE_PROJECT_DIR:-.}" || exit 0
echo "Session preflight (report only; if anything is missing, use 1-3-1, do not install or start it):"

sdks=$(dotnet --list-sdks 2>/dev/null | awk '{print $1}' | tr '\n' ' ')
case " $sdks" in
  *" 8."*) echo "- .NET SDK: OK (installed: $sdks). Target framework must stay net8.0." ;;
  *) echo "- .NET SDK: MISSING 8.x (installed: ${sdks:-none}). Do NOT downgrade net8.0. Present a 1-3-1." ;;
esac

if docker info >/dev/null 2>&1; then echo "- Docker: running"; else echo "- Docker: not running (do not start it; ask the human if you need it)"; fi

if [ "$(git config core.hooksPath 2>/dev/null)" = ".githooks" ]; then echo "- Git hooks: enabled"; else echo "- Git hooks: NOT enabled in this clone (ask the human to run: git config core.hooksPath .githooks)"; fi
echo "- Git: branch $(git branch --show-current 2>/dev/null), $(git status --porcelain 2>/dev/null | wc -l | tr -d ' ') uncommitted path(s), email $(git config user.email 2>/dev/null || echo unset)"

if [ -f ai-session/PLAN.md ]; then
  next=$(grep -m1 -E '^\s*- \[ \]' ai-session/PLAN.md | sed 's/^\s*- \[ \] //')
  echo "- Plan: next unchecked slice: ${next:-none (all done, or the plan needs updating)}"
else
  echo "- Plan: no ai-session/PLAN.md yet. Explore, then propose a plan before any code."
fi
exit 0

#!/usr/bin/env bash
# PostToolUse on Edit|Write: format the C# file the agent just wrote, so the quality gate never fails on whitespace.
input=$(cat)
file=$(printf '%s' "$input" | sed -n 's/.*"file_path"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
case "$file" in
  *.cs) ;;
  *) exit 0 ;;
esac
cd "${CLAUDE_PROJECT_DIR:-.}" || exit 0
rel=${file#"$PWD"/}
# whitespace formatting only: fast, and needs no build
dotnet format whitespace StockApi.sln --include "$rel" >/dev/null 2>&1 || true
exit 0

#!/usr/bin/env sh
# Runs for every committer, human or agent. Enable once per clone: git config core.hooksPath .githooks
fail() { echo "pre-commit: $1" >&2; exit 1; }

# 1. No build output, local databases or env files.
bad=$(git diff --cached --name-only | grep -E '(^|/)(bin|obj|tmp)/|\.db$|(^|/)\.env$')
[ -n "$bad" ] && fail "refusing to commit build output or local files:
$bad
Unstage with: git restore --staged <path>"

# 2. Work identity. Change yourcompany.com to your own work email domain.
case "$(git config user.email)" in
  *@yourcompany.com) ;;
  *) fail "author email '$(git config user.email)' is not your work address. Run: git config user.email you@yourcompany.com" ;;
esac

# 3. Secrets: a pattern check for config-style secrets, which gitleaks misses on low-entropy values
#    such as "SuperSecretAuthenticationKey…" (measured 2026-09-30), then gitleaks for known key formats.
# ai-session/ holds raw transcripts, which quote config on purpose; gitleaks still scans them below.
hits=$(git diff --cached -U0 -- . ':(exclude)ai-session' | grep -E '^\+' | grep -nEi '(key|secret|password|pwd|token)["'\'' ]*[:=] *["'\''][^"'\'' ]{8,}')
[ -n "$hits" ] && fail "possible secret in staged changes (move it to .env, document it in .env.example):
$hits"
if command -v gitleaks >/dev/null 2>&1; then
  gitleaks git --pre-commit --staged --redact --no-banner || fail "gitleaks found a secret (see above)."
else
  echo "pre-commit: gitleaks not installed; only the pattern check ran" >&2
fi

# 4. Formatting.
dotnet format --verify-no-changes >/dev/null 2>&1 || fail "formatting drift. Run: dotnet format"

exit 0

#!/usr/bin/env sh
# Conventional Commits subject, and no AI attribution. No Node needed.
msg_file="$1"
subject=$(head -n1 "$msg_file")

case "$subject" in
  Merge\ *|Revert\ *) exit 0 ;;
esac

echo "$subject" | grep -Eq '^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-z0-9._/-]+\))?!?: .{1,72}$' || {
  echo "commit-msg: subject must be 'type(scope): summary' (Conventional Commits, max 72 chars after the colon)." >&2
  echo "  got: $subject" >&2
  exit 1
}

if grep -Eqi '^(co-authored-by: .*(claude|codex|gemini|copilot|anthropic|openai|noreply@)|.*generated with .*(claude|codex|gemini|antigravity))' "$msg_file"; then
  echo "commit-msg: AI attribution lines are not allowed in this repo. Remove the trailer." >&2
  exit 1
fi
exit 0

using System.Net;
using System.Net.Http.Json;
using StockApi.Domain;

namespace StockApi.Tests;

public class ConcurrencyTests : IClassFixture<FileStockApiFactory>
{
    private readonly HttpClient _client;

    public ConcurrencyTests(FileStockApiFactory factory) => _client = factory.CreateClient();

    [Fact]
    public async Task PlaceOrder_TwelveConcurrentOrdersForThreeUnits_ExactlyThreeSucceed()
    {
        var product = await _client.CreateProductAsync("CONC-1", 3);

        // Hold every request at a gate and release them together so they really overlap.
        var gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
        var inFlight = Enumerable.Range(0, 12).Select(_ => Task.Run(async () =>
        {
            await gate.Task;
            return await _client.PostAsJsonAsync("/api/orders", new { productId = product.Id, quantity = 1 });
        })).ToList();
        gate.SetResult();
        var responses = await Task.WhenAll(inFlight);

        Assert.Equal(3, responses.Count(r => r.StatusCode == HttpStatusCode.Created));
        Assert.Equal(9, responses.Count(r => r.StatusCode == HttpStatusCode.Conflict));
        var after = await _client.GetFromJsonAsync<Product>($"/api/products/{product.Id}");
        Assert.Equal(0, after!.Stock);
    }
}

using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using StockApi.Data;

namespace StockApi.Tests;

/// <summary>Real SQLite on a unique temp file: a shared in-memory connection is not thread-safe, so concurrency tests need a file.</summary>
public class FileStockApiFactory : WebApplicationFactory<Program>
{
    private readonly string _path = Path.Combine(Path.GetTempPath(), $"stockapi-{Guid.NewGuid():N}.db");

    protected override void ConfigureWebHost(IWebHostBuilder builder) =>
        builder.ConfigureServices(services =>
        {
            var existing = services.Single(d => d.ServiceType == typeof(DbContextOptions<StockDbContext>));
            services.Remove(existing);
            services.AddDbContext<StockDbContext>(o => o.UseSqlite($"Data Source={_path};Default Timeout=30"));
        });

    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);
        if (!disposing) return;
        Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
        foreach (var suffix in new[] { "", "-wal", "-shm" })
            File.Delete(_path + suffix);
    }
}