dotnet-production-agent-skills 0.2.0 → 0.3.0

package/README.md

@@ -10,7 +10,7 @@
 
 A focused collection of `SKILL.md` guidance built to reduce repeated prompting, unnecessary token use, and avoidable rework when developing production .NET software with AI coding tools.
 
-[Browse the skills catalog](https://dprakash2101.github.io/dotnet-production-agent-skills/#skills) · [Build an install command](https://dprakash2101.github.io/dotnet-production-agent-skills/#install) · [Report an issue](https://github.com/dprakash2101/dotnet-production-agent-skills/issues)
+[Browse the skills catalog](https://dprakash2101.github.io/dotnet-production-agent-skills/#skills) · [Build an install command](https://dprakash2101.github.io/dotnet-production-agent-skills/#install) · [Release notes](RELEASE_NOTES.md) · [Report an issue](https://github.com/dprakash2101/dotnet-production-agent-skills/issues)
 
 </div>
 
@@ -36,6 +36,7 @@ A focused collection of `SKILL.md` guidance built to reduce repeated prompting,
   - [Safety & Conflict Handling](#safety--conflict-handling)
 - [Host Compatibility](#host-compatibility)
 - [Validation & Development](#validation--development)
+- [Release Notes](#release-notes)
 - [Why I built this](#why-i-built-this)
 - [License](#license)
 
@@ -58,7 +59,8 @@ skills/ (canonical portable Agent Skills)
          ├── Codex         →  .agents/skills
          ├── GitHub Copilot →  .github/skills | .copilot/skills
          ├── Claude Code   →  .claude/skills
-         └── Cursor        →  .cursor/skills | .agents/skills
+         ├── Cursor        →  .cursor/skills | .agents/skills
+         └── Antigravity   →  .agents/skills + .agents/hooks.json
 ```
 
 ### Core Engineering Invariant
@@ -201,12 +203,14 @@ The catalog is grouped by task so agents can load only the guidance relevant to
 | [`google-cloud-pubsub-dotnet`](skills/google-cloud-pubsub-dotnet/SKILL.md) | Implement robust Google Cloud Pub/Sub publishers and pull subscribers with proper ack/nack semantics. | [client-patterns](skills/google-cloud-pubsub-dotnet/references/client-patterns.md) |
 | [`google-bigquery-dotnet`](skills/google-bigquery-dotnet/SKILL.md) | Query BigQuery with parameterization, pagination, streaming buffers, and strict query-cost awareness. | [query-safety](skills/google-bigquery-dotnet/references/query-safety.md) |
 | [`google-firestore-dotnet`](skills/google-firestore-dotnet/SKILL.md) | Model Firestore documents, transactions, and batched writes with concurrency and read-cost awareness. | — |
+| [`redis-dotnet`](skills/redis-dotnet/SKILL.md) | Design secure .NET Redis caches, expiration, invalidation, and token protection. | — |
 
 ### 6. ⚡ Distributed Resilience & Security
 
 | Skill | Focus & Trigger | Progressive References |
 | :--- | :--- | :--- |
 | [`distributed-workflows`](skills/distributed-workflows/SKILL.md) | Build idempotent consumers, handle partial failures, manage distributed retries, and design background workers. | — |
+| [`retry-resilience`](skills/retry-resilience/SKILL.md) | Add explicitly requested retries or review existing transient failure policies; avoid automatic retries. | — |
 | [`dotnet-security`](skills/dotnet-security/SKILL.md) | Threat-model .NET boundaries, protect against SSRF/XSS/SQLi, enforce authorization, and handle secrets safely. | — |
 | [`production-logging`](skills/production-logging/SKILL.md) | Produce structured, high-signal, sensitive-data-masked, and cost-efficient Serilog/ILogger production logs. | — |
 
@@ -283,9 +287,11 @@ External consumers are never assumed absent just because no internal repository
 | :--- | :--- | :--- |
 | Universal engineering rules | Managed section in project `.github/copilot-instructions.md` | Every Copilot coding task in that project |
 | Specialized .NET knowledge | Individual `SKILL.md` files | The coding agent selects relevant skills from their descriptions and the request |
-| Deterministic command enforcement | Optional host hooks/guardrails | Only when a supported host integration and policy are explicitly enabled |
+| Deterministic command enforcement | Project hooks/guardrails | Installed for Codex, Copilot, Claude Code, Cursor, and Antigravity in project scope |
 
-The CLI installs and manages guidance; it does not route prompts or load every skill for every task. Clear skill descriptions help the coding agent select relevant knowledge. Universal rules belong in repository instructions. Command blocking belongs in host-supported hooks. Hook installation is currently an extension point in `src/copilot/hooks.ts`; no command hook is installed because a portable supported Copilot hook configuration has not been established.
+The CLI installs and manages guidance; it does not route prompts or load every skill for every task. Clear skill descriptions help the coding agent select relevant knowledge. Universal rules belong in repository instructions. Command blocking belongs in host-supported hooks. Project installs now configure native hooks for every supported coding agent using one shared, dependency-free guard script. Existing unrelated hook entries are preserved.
+
+The initial policy blocks force-push, destructive Git reset/clean/branch deletion, broad recursive deletion, and direct access to common credential-bearing files. Safe commands continue normally. Host configuration is written to `.codex/hooks.json`, `.github/hooks/dotnet-production-agent-skills.json`, `.claude/settings.json`, `.cursor/hooks.json`, or `.agents/hooks.json` for Antigravity.
 
 Copilot project installs manage only the text between `<!-- dotnet-production-agent-skills:start -->` and `<!-- dotnet-production-agent-skills:end -->`. Existing team instructions outside those markers remain intact. Uninstall removes only the managed section. User-scope Copilot installs install skills into `~/.copilot/skills`; repository instructions apply only to project scope.
 
@@ -316,7 +322,7 @@ Commands:
 
 | Flag | Description | Default |
 | :--- | :--- | :--- |
-| `--target <host>` | Target agent: `all`, `shared`, `codex`, `copilot`, `claude`, `cursor` | `all` |
+| `--target <host>` | Target agent: `all`, `shared`, `codex`, `copilot`, `claude`, `cursor`, `antigravity` | `all` |
 | `--scope <scope>` | Installation scope: `user` (home dir) or `project` (repository dir) | `user` |
 | `--project <path>`| Explicit path to repository root (forces `--scope project`) | Current dir |
 | `--mode <mode>`   | Installation mode: `copy` (portable) or `link` (symlinks) | `copy` |
@@ -333,6 +339,7 @@ Commands:
 | `copilot` | `~/.copilot/skills` | `<project>/.github/skills` |
 | `claude` | `~/.claude/skills` | `<project>/.claude/skills` |
 | `cursor` | `~/.cursor/skills` | `<project>/.cursor/skills` |
+| `antigravity` | `~/.agents/skills` | `<project>/.agents/skills` |
 | `all` | `~/.agents/skills` + `~/.claude/skills` | `<project>/.agents/skills` + `<project>/.claude/skills` |
 
 ### Safety & Conflict Handling
@@ -352,6 +359,7 @@ Commands:
 | **GitHub Copilot** | `.github/skills`, `.agents/skills` | Installs to `.github/skills` (project) or `.copilot/skills` (user) | Surface capabilities vary across VS Code, Visual Studio, and JetBrains. |
 | **Claude Code** | Portable `SKILL.md` in `.claude/skills` | Direct copy or symlink into `.claude/skills` | Supports project & user scopes. Committed project skills recommended for team consistency. |
 | **Cursor** | `.cursor/skills` and `.agents/skills` | Installs to `.cursor/skills` or shared `.agents/skills` | Auto-detects compatible `.agents/skills` layouts. |
+| **Google Antigravity** | `.agents/skills` and `.agents/hooks.json` | Uses shared skills plus a native project hook adapter | Works across Antigravity 2.0, CLI, and IDE workspace customization. |
 
 ---
 
@@ -368,7 +376,7 @@ GitHub Actions publishes the package from [`.github/workflows/publish-npm.yml`](
    - **Workflow dispatch**: choose `keep` to publish the current `package.json` version as-is, or `patch` / `minor` / `major` / `prerelease` to bump first. Optionally override the npm dist-tag, and optionally commit/tag changes back to the branch before publish.
 3. Dist-tags default from the version (`latest` for stable, `beta` / `next` / `alpha` / `rc` for matching prereleases) unless you override them on dispatch.
 
-`package.json` is the version source of truth. If `package-lock.json` root version drifts, the workflow aligns the lockfile to `package.json` (or the release tag) without inventing a new semver. `keep` does not bump; it only publishes the current version (after any lock sync). Republishing a version that already exists on npm is still rejected.
+For GitHub release events, the semver release tag is authoritative and both package files are aligned to it before the npm availability check. For manual workflow runs, `package.json` remains the version source of truth. If `package-lock.json` drifts, the workflow aligns it without inventing another semver. `keep` does not bump; it only publishes the current version after lock synchronization. Republishing the resolved version is still rejected.
 
 Successful publishes are recorded under the repository **npm** environment (Deployments on the GitHub repo page) and link to the published package version on npmjs.com.
 
@@ -396,6 +404,10 @@ npm pack --dry-run
 
 ---
 
+## Release Notes
+
+See [release notes](RELEASE_NOTES.md) or the [documentation page](https://dprakash2101.github.io/dotnet-production-agent-skills/release-notes.html) for changes, compatibility notes, and publication status.
+
 ## Why I built this
 
 I created **dotnet-production-agent-skills** after repeatedly explaining the same production expectations to GitHub Copilot—then spending more tokens correcting and reworking the result. This project captures those lessons as focused, reusable guidance so coding agents can start with better context and produce safer .NET code the first time.

package/RELEASE_NOTES.md

@@ -0,0 +1,59 @@
+# Release notes
+
+## v0.3.0 — Multi-agent hooks and Antigravity
+
+### New
+
+- Added `antigravity` as a first-class CLI target using `.agents/skills` and native project hooks in `.agents/hooks.json`.
+- Project installs can now configure command guardrails for Codex, GitHub Copilot, Claude Code, Cursor, and Google Antigravity. `--target all --scope project` installs all five adapters.
+- Added a shared, dependency-free guard script that blocks force-push, destructive Git operations, broad recursive deletion, and direct access to common credential-bearing files.
+- `list` and `doctor` report each project hook installation. Updates are idempotent, unrelated existing hook entries are preserved, and uninstall removes only package-managed entries.
+
+### Compatibility
+
+- Existing targets, scopes, copy/link modes, dry runs, conflict handling, and managed Copilot instructions remain supported.
+- Hooks are installed only for project scope. User-scope behavior is unchanged.
+
+### Release pipeline
+
+- GitHub release tags are authoritative for release-triggered npm publishes. A `v0.3.0` release aligns both package files to `0.3.0` before checking npm availability or publishing, even when the tagged commit still contains an already-published version.
+- The workflow now fails early if the resolved tag version and `package.json` ever disagree, preventing an old package version from being checked or published accidentally.
+
+## Unreleased — Redis caching skill
+
+Proposed in [PR #6](https://github.com/dprakash2101/dotnet-production-agent-skills/pull/6); this change is not yet published to npm.
+
+### New
+
+- Added `redis-dotnet` guidance for .NET and ASP.NET Core Redis caching: key design, expiration, invalidation, concurrency, failure handling, and targeted validation.
+- The skill prohibits plaintext credentials in Redis. Credential ciphertext must be bound to the cache key, trusted tenant/account, and credential purpose using authenticated associated data or equivalent purpose isolation, with encryption keys outside Redis. Tests must reject ciphertext copied to another key, tenant/account, or purpose.
+- Added the skill to the README and website catalog.
+
+## v0.2.0 — Copilot instructions and safer skill management
+
+The implementation was merged in [PR #4](https://github.com/dprakash2101/dotnet-production-agent-skills/pull/4) and published as [`dotnet-production-agent-skills@0.2.0`](https://www.npmjs.com/package/dotnet-production-agent-skills/v/0.2.0). These notes document that release; the release notes page is a follow-up documentation change.
+
+### New
+
+- Copilot project installs manage an always-on engineering section in `.github/copilot-instructions.md`. Existing team instructions outside the managed markers remain intact; uninstall removes only the managed section.
+- A `retry-resilience` skill covers explicitly requested retries and reviews of existing retry policies. Its guidance avoids introducing retries automatically.
+- The CLI has a separate Copilot hooks interface for future command guardrails. No hooks are installed by this change.
+
+### Improved
+
+- Repeated installs skip unchanged managed skills. An updated packaged skill replaces an unchanged installed copy.
+- Forced uninstall backs up locally edited managed skills and reports the backup path.
+- `doctor` parses YAML frontmatter, accepts multiline descriptions, checks skill metadata and local references, reports packaged updates and Copilot instruction state, and exits nonzero for installation or validation errors.
+- Skill descriptions now give agents clearer cues for selecting task-specific guidance. Copilot installation output includes skill discovery commands.
+- CLI help displays the published executable name, `dotnet-production-agent-skills`.
+
+### Compatibility and upgrade
+
+- Targets (`all`, `shared`, `codex`, `copilot`, `claude`, `cursor`), user and project scopes, copy and link modes, and existing CLI flags remain supported.
+- Copilot instructions are added only for project-scope Copilot installs (including `--target all --scope project`). User-scope Copilot installs continue to install skills in `~/.copilot/skills`.
+- Review any local skill edits before updating. The CLI still requires `--force --yes` for noninteractive replacement of conflicts, with a backup of the replaced content.
+- The CLI now depends on the `yaml` npm package. Install the package normally so npm resolves its runtime dependency.
+
+### Validation
+
+`npm run validate` passed: 30 packaged skills validated and 14 CLI tests passed. The CLI help, Copilot install dry run, doctor output, package dry run, and `git diff --check` were also exercised.

package/dist/src/cli.js

@@ -7,11 +7,12 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { changeInstructions, inspectInstructions } from "./copilot/instructions.js";
+import { changeHooks, hookTargets, inspectHooks, removeSharedHookScript } from "./hooks.js";
 import { validateSkills } from "./skills/validation.js";
 const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const SKILLS_ROOT = path.join(PACKAGE_ROOT, "skills");
 const MANIFEST_NAME = ".dotnet-agent-skills.json";
-const SUPPORTED_TARGETS = new Set(["all", "shared", "codex", "copilot", "claude", "cursor"]);
+const SUPPORTED_TARGETS = new Set(["all", "shared", "codex", "copilot", "claude", "cursor", "antigravity"]);
 function usage() {
     return `Usage: dotnet-production-agent-skills <command> [options]
 
@@ -23,7 +24,8 @@ Commands:
   uninstall    Remove only skills tracked by this package
 
 Options:
-  --target <all|shared|codex|copilot|claude|cursor>  Default: all
+  --target <all|shared|codex|copilot|claude|cursor|antigravity>
+                                                      Default: all
   --scope <user|project>                             Default: user
   --project <path>                                   Project root; implies project scope
   --mode <copy|link>                                 Default: copy
@@ -33,8 +35,9 @@ Options:
   --json                                             JSON output for list/doctor
   -h, --help                                         Show help
 
-For --target all, one shared .agents/skills installation serves Codex, Copilot,
-and Cursor; a second .claude/skills installation serves Claude Code.`;
+For --target all, one shared .agents/skills installation serves compatible agents,
+a second .claude/skills installation serves Claude Code, and project scope installs
+native command-guardrail hooks for Codex, Copilot, Claude, Cursor, and Antigravity.`;
 }
 function requireValue(argv, index, option) {
     const value = argv[index + 1];
@@ -103,6 +106,7 @@ function destinations(options) {
             copilot: ".copilot/skills",
             claude: ".claude/skills",
             cursor: ".cursor/skills",
+            antigravity: ".agents/skills",
         }
         : {
             shared: ".agents/skills",
@@ -110,6 +114,7 @@ function destinations(options) {
             copilot: ".github/skills",
             claude: ".claude/skills",
             cursor: ".cursor/skills",
+            antigravity: ".agents/skills",
         };
     const targets = options.target === "all" ? ["shared", "claude"] : [options.target];
     const unique = new Map();
@@ -235,6 +240,9 @@ async function installOrUpdate(options, command) {
         if (instructions.state === "malformed")
             throw new Error(`malformed managed Copilot instructions: ${instructions.path}`);
     }
+    if (options.scope === "project") {
+        await Promise.all(hookTargets(options.target).map((target) => inspectHooks(options.project, PACKAGE_ROOT, target)));
+    }
     const packaged = new Set(skills);
     const packageJson = JSON.parse(await readFile(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
     const destinationPlans = [];
@@ -328,6 +336,12 @@ async function installOrUpdate(options, command) {
         if (!options.dryRun)
             console.log("Copilot CLI: /skills list | /skills reload | /skills info <skill-name>");
     }
+    if (options.scope === "project") {
+        for (const target of hookTargets(options.target)) {
+            const action = await changeHooks(options.project, PACKAGE_ROOT, target, "install", options.dryRun);
+            console.log(`${action === "skip" ? "skip" : options.dryRun ? `would ${action}` : action} ${target} project hooks`);
+        }
+    }
 }
 async function uninstall(options) {
     if ((options.target === "copilot" || options.target === "all") && options.scope === "project") {
@@ -335,6 +349,9 @@ async function uninstall(options) {
         if (instructions.state === "malformed")
             throw new Error(`malformed managed Copilot instructions: ${instructions.path}`);
     }
+    if (options.scope === "project") {
+        await Promise.all(hookTargets(options.target).map((target) => inspectHooks(options.project, PACKAGE_ROOT, target)));
+    }
     const destinationPlans = [];
     for (const destination of destinations(options)) {
         const manifest = await readManifest(destination.directory);
@@ -380,6 +397,16 @@ async function uninstall(options) {
         if (action !== "skip")
             console.log(`${options.dryRun ? "would remove" : "remove"} Copilot production instructions`);
     }
+    if (options.scope === "project") {
+        const targets = hookTargets(options.target);
+        for (const target of targets) {
+            const action = await changeHooks(options.project, PACKAGE_ROOT, target, "uninstall", options.dryRun);
+            if (action !== "skip")
+                console.log(`${options.dryRun ? "would remove" : "remove"} ${target} project hooks`);
+        }
+        if (options.target === "all" && targets.length > 0)
+            await removeSharedHookScript(options.project, options.dryRun);
+    }
 }
 async function inspect(options) {
     const skills = await packagedSkills();
@@ -405,7 +432,11 @@ async function inspect(options) {
     }
     const copilotInstructions = (options.target === "copilot" || options.target === "all") && options.scope === "project"
         ? await inspectInstructions(options.project) : undefined;
-    return { packagedSkills: skills, currentPackageVersion: packageJson.version, installations, ...(copilotInstructions ? { copilotInstructions } : {}) };
+    const hooks = options.scope === "project"
+        ? await Promise.all(hookTargets(options.target).map((target) => inspectHooks(options.project, PACKAGE_ROOT, target)))
+        : undefined;
+    return { packagedSkills: skills, currentPackageVersion: packageJson.version, installations,
+        ...(copilotInstructions ? { copilotInstructions } : {}), ...(hooks ? { hooks } : {}) };
 }
 async function validateCanonical() {
     return validateSkills(SKILLS_ROOT, await packagedSkills());
@@ -442,7 +473,8 @@ async function main() {
             const unhealthy = report.installations.flatMap((entry) => entry.skills)
                 .filter((entry) => entry.state !== "unchanged" || entry.packaged === "outdated");
             const instructionsUnhealthy = report.copilotInstructions && !["unchanged", "unmanaged"].includes(report.copilotInstructions.state);
-            const output = { ...report, validationErrors, healthy: validationErrors.length === 0 && unhealthy.length === 0 && !instructionsUnhealthy };
+            const hooksUnhealthy = report.hooks?.some((hook) => hook.state !== "unchanged") ?? false;
+            const output = { ...report, validationErrors, healthy: validationErrors.length === 0 && unhealthy.length === 0 && !instructionsUnhealthy && !hooksUnhealthy };
             if (parsed.options.json)
                 console.log(JSON.stringify(output, null, 2));
             else {
@@ -459,6 +491,7 @@ async function main() {
                 }
                 if (report.copilotInstructions)
                     console.log(`Copilot instructions: ${report.copilotInstructions.state} ${report.copilotInstructions.path}`);
+                report.hooks?.forEach((hook) => console.log(`${hook.target} hooks: ${hook.state} ${hook.config}`));
                 validationErrors.forEach((error) => console.error(`error: ${error}`));
             }
             if (command === "doctor" && !output.healthy)

package/dist/src/hooks.js

@@ -0,0 +1,138 @@
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+const OWNER = "dotnet-production-agent-skills";
+const COMMAND = "node .agent-guardrails/guard.mjs";
+const SCRIPT_DIRECTORY = ".agent-guardrails";
+const SCRIPT_NAME = "guard.mjs";
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readJson(file) {
+    try {
+        const parsed = JSON.parse(await readFile(file, "utf8"));
+        if (!isObject(parsed))
+            throw new Error("root must be a JSON object");
+        return parsed;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return {};
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid hook configuration ${file}: ${detail}`);
+    }
+}
+function locations(projectRoot, target) {
+    const configs = {
+        codex: ".codex/hooks.json",
+        copilot: ".github/hooks/dotnet-production-agent-skills.json",
+        claude: ".claude/settings.json",
+        cursor: ".cursor/hooks.json",
+        antigravity: ".agents/hooks.json",
+    };
+    return { config: path.join(projectRoot, configs[target]), script: path.join(projectRoot, SCRIPT_DIRECTORY, SCRIPT_NAME) };
+}
+function handler(target) {
+    return { type: "command", command: `${COMMAND} ${target}`, timeout: 10 };
+}
+function managedGroup(target) {
+    return { matcher: target === "antigravity" ? "run_command|view_file|write_to_file|replace_file_content|multi_replace_file_content" : "Bash|PowerShell|Read|Write|Edit", hooks: [handler(target)] };
+}
+function containsManaged(value) {
+    return JSON.stringify(value).includes(COMMAND);
+}
+function withoutManaged(value) {
+    return Array.isArray(value) ? value.filter((entry) => !containsManaged(entry)) : [];
+}
+function mergeConfig(current, target, install) {
+    if (target === "copilot") {
+        return install ? {
+            version: 1,
+            description: `${OWNER} project command guardrails`,
+            hooks: { preToolUse: [{ type: "command", command: `${COMMAND} copilot`, timeoutSec: 10 }] },
+        } : {};
+    }
+    if (target === "antigravity") {
+        const next = { ...current };
+        if (install)
+            next[OWNER] = { enabled: true, PreToolUse: [managedGroup(target)] };
+        else
+            delete next[OWNER];
+        return next;
+    }
+    const hooks = isObject(current.hooks) ? { ...current.hooks } : {};
+    const event = target === "cursor" ? "preToolUse" : "PreToolUse";
+    const entries = withoutManaged(hooks[event]);
+    if (install)
+        entries.push(target === "cursor"
+            ? { command: `${COMMAND} cursor`, timeout: 10, matcher: "Shell|Read|Write", failClosed: true }
+            : managedGroup(target));
+    if (entries.length)
+        hooks[event] = entries;
+    else
+        delete hooks[event];
+    const next = { ...current };
+    if (target === "cursor")
+        next.version = typeof current.version === "number" ? current.version : 1;
+    if (Object.keys(hooks).length)
+        next.hooks = hooks;
+    else
+        delete next.hooks;
+    return next;
+}
+async function expectedScript(packageRoot) {
+    return readFile(path.join(packageRoot, "hooks", SCRIPT_NAME), "utf8");
+}
+export async function inspectHooks(projectRoot, packageRoot, target) {
+    const files = locations(projectRoot, target);
+    try {
+        const [current, script] = await Promise.all([readJson(files.config), readFile(files.script, "utf8")]);
+        const expected = mergeConfig(current, target, true);
+        const configMatches = JSON.stringify(current) === JSON.stringify(expected);
+        return { target, state: configMatches && script === await expectedScript(packageRoot) ? "unchanged" : "modified", ...files };
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return { target, state: "missing", ...files };
+        throw error;
+    }
+}
+export async function changeHooks(projectRoot, packageRoot, target, action, dryRun) {
+    const files = locations(projectRoot, target);
+    const current = await readJson(files.config);
+    const next = mergeConfig(current, target, action === "install");
+    const hasConfigChange = JSON.stringify(current) !== JSON.stringify(next);
+    let scriptMatches = false;
+    try {
+        scriptMatches = await readFile(files.script, "utf8") === await expectedScript(packageRoot);
+    }
+    catch { /* missing */ }
+    if (action === "install") {
+        if (!hasConfigChange && scriptMatches)
+            return "skip";
+        if (!dryRun) {
+            await mkdir(path.dirname(files.config), { recursive: true });
+            await mkdir(path.dirname(files.script), { recursive: true });
+            await writeFile(files.config, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+            await cp(path.join(packageRoot, "hooks", SCRIPT_NAME), files.script);
+        }
+        return Object.keys(current).length ? "update" : "install";
+    }
+    if (!hasConfigChange)
+        return "skip";
+    if (!dryRun) {
+        if (Object.keys(next).length)
+            await writeFile(files.config, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+        else
+            await rm(files.config, { force: true });
+    }
+    return "remove";
+}
+export function hookTargets(target) {
+    if (target === "all")
+        return ["codex", "copilot", "claude", "cursor", "antigravity"];
+    return target === "shared" ? [] : [target];
+}
+export async function removeSharedHookScript(projectRoot, dryRun) {
+    if (!dryRun)
+        await rm(path.join(projectRoot, SCRIPT_DIRECTORY), { recursive: true, force: true });
+}

package/hooks/guard.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+const host = process.argv[2] ?? "unknown";
+let input = {};
+try {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  input = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+} catch {
+  process.stderr.write("Guardrail input was not valid JSON.\n");
+  process.exit(2);
+}
+
+const tool = input.tool_name ?? input.toolName ?? input.toolCall?.name ?? "";
+const args = input.tool_input ?? input.toolArgs ?? input.toolCall?.args ?? {};
+const command = String(args.command ?? args.CommandLine ?? args.script ?? "").trim();
+const file = String(args.file_path ?? args.path ?? args.TargetFile ?? args.AbsolutePath ?? "").replaceAll("\\", "/");
+
+const checks = [
+  [/\bgit\s+push\b[^\n;&|]*(?:--force(?:-with-lease)?|-f)\b/i, "Force-push is blocked. Use a normal push or request explicit human approval."],
+  [/\bgit\s+(?:reset\s+--hard|clean\s+-[^\s]*f[^\s]*|branch\s+-D)(?:\s|$)/i, "Destructive Git operations are blocked. Preserve work and request explicit human approval."],
+  [/(?:^|[;&|]\s*)(?:rm\s+-[^\s]*r[^\s]*f|Remove-Item\b[^\n;&|]*-Recurse[^\n;&|]*-Force)\s+(?:\/|~|\$HOME|\$env:USERPROFILE)(?:\s|$)/i, "Recursive deletion of a broad system or home path is blocked."],
+  [/(?:cat|type|Get-Content|more|less)\s+[^\n;&|]*(?:\.env(?:\.|\s|$)|id_(?:rsa|ed25519)|\.pem\b|\.pfx\b|secrets\.json\b)/i, "Reading credential-bearing files through the shell is blocked."],
+];
+
+const sensitivePath = /(?:^|\/)(?:\.env(?:\.[^/]*)?|id_(?:rsa|ed25519)|[^/]*\.(?:pem|pfx)|secrets\.json)$/i;
+let reason = sensitivePath.test(file) ? "Direct access to a credential-bearing file is blocked." : "";
+if (!reason && command) reason = checks.find(([pattern]) => pattern.test(command))?.[1] ?? "";
+
+function response(decision, message = "") {
+  if (host === "cursor") return decision === "deny"
+    ? { permission: "deny", user_message: message, agent_message: message }
+    : { permission: "allow" };
+  if (host === "antigravity") return { decision, ...(message ? { reason: message } : {}) };
+  if (host === "copilot") return decision === "deny"
+    ? { permissionDecision: "deny", permissionDecisionReason: message }
+    : { permissionDecision: "allow" };
+  return decision === "deny" ? {
+    hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: message },
+  } : {};
+}
+
+process.stdout.write(`${JSON.stringify(response(reason ? "deny" : "allow", reason))}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotnet-production-agent-skills",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Portable production .NET engineering skills for coding agents",
   "license": "MIT",
   "author": {
@@ -21,8 +21,10 @@
   },
   "files": [
     "dist/src",
+    "hooks",
     "copilot",
     "skills",
+    "RELEASE_NOTES.md",
     "README.md",
     "LICENSE"
   ],
@@ -35,7 +37,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "test": "npm run build && node --test dist/test/cli.test.js",
+    "test": "npm run build && node --test dist/test/cli.test.js scripts/*.test.mjs",
     "validate": "python3 scripts/validate_skills.py && npm test",
     "prepack": "npm run build"
   },
@@ -49,7 +51,8 @@
     "codex",
     "copilot",
     "claude-code",
-    "cursor"
+    "cursor",
+    "antigravity"
   ],
   "dependencies": {
     "yaml": "^2.9.1"

package/skills/redis-dotnet/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: redis-dotnet
+description: Implement, review, or troubleshoot Redis caching in .NET and ASP.NET Core, including StackExchange.Redis, IDistributedCache, key design, expiration, cache invalidation, performance, and secure handling of cached tokens or secrets.
+---
+
+# Redis caching for .NET
+
+Inspect the application's existing cache abstraction, Redis client registration, serializers, and failure policy before changing code. Reuse established helpers and avoid adding a second connection or serialization scheme without a reason.
+
+- Choose a stable namespaced key with environment and tenant/customer isolation where needed. Do not place access tokens, secret keys, passwords, or sensitive personal data in key names; keys appear in diagnostics and operational tools.
+- Set an explicit TTL from the data's real validity. For access tokens, expire the cache entry before the token's expiry with a small safety margin, and handle refresh races across instances. Define invalidation when source data changes. Avoid unbounded or permanently cached entries by default.
+- Keep values small and version serialized payloads when schemas can change. Do not cache null/error responses without a deliberate short-lived policy. Avoid large scans, blocking commands, and per-request connection creation; bound timeouts and concurrency.
+- **Never store access tokens, refresh tokens, API keys, secret keys, passwords, or other credentials in Redis as plaintext values.** Prefer caching a non-sensitive reference when possible. If a credential must be cached, encrypt before writing and decrypt only after reading. Require the established, vetted helper to authenticate the intended cache key, trusted tenant/account identity, and credential purpose as associated data (AAD), or provide equivalent purpose isolation for that exact context. Derive the same unambiguous, versioned context independently from the authorized request and computed key on both paths; never accept tenant or purpose solely from Redis or the ciphertext. Reject a mismatch without returning or using the credential. If the helper cannot bind this context, extend or wrap it safely before caching credentials. Keep encryption keys outside Redis in the existing secret-management system and support key rotation; do not invent cryptography.
+- Protect Redis transport with TLS and restrict access using the deployment's network and least-privilege authentication controls. Encryption in transit or at rest does not replace application-level protection of sensitive cached values. Do not log cache values, credentials, connection strings, or decrypted payloads.
+- Decide whether a Redis miss or outage should fall back to the source, fail closed, or surface an error based on the flow. Avoid a thundering herd on misses and keep any lock or refresh mechanism bounded. Add retries only when requested or required by existing architecture.
+- Test expiration, invalidation, tenant isolation, concurrent cache misses, serialization changes, and Redis failure behavior where relevant. For credential caching, verify plaintext secrecy, decrypt failures, and key rotation. Copy a valid ciphertext to another cache key, tenant/account, or credential purpose and verify decryption or use fails closed in each case.

package/dist/src/copilot/hooks.js

@@ -1 +0,0 @@
-export {};