tda-agent-safety-guardrails

Reviews and enforces agent safety boundaries around git operations, hooks, and result artifacts.

1|Updated Dec 13, 2025
One-click install
npx skills add https://github.com/ZK-Theory/TDL --skill tda-agent-safety-guardrails-zk-theory
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: tda-agent-safety-guardrails
Source: https://github.com/ZK-Theory/TDL/tree/main/.agents/skills/tda-agent-safety-guardrails
Command: npx skills add https://github.com/ZK-Theory/TDL --skill tda-agent-safety-guardrails-zk-theory

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Autonomous coding agents can silently bypass enforcement hooks, push to shared branches, overwrite immutable result artifacts, or sweep unrelated files into commits. This Skill defines the blocking rules and review checks that keep agent behavior inside the repository's safety boundaries. ## Core Features & Use Cases - Destructive-operation blocking: Blocks or requires explicit confirmation for git push to shared branches, git reset --hard, force-pushes, git commit --no-verify, and deletion of result artifacts. - Environment review checklist: Verifies pre-commit contract gates, write-time hooks (notation guard, results no-overwrite, dispatch-readiness guard), staged-file scope, and worktree setup before dispatch. - Escalation protocol: Surfaces conflicts between guardrails and user instructions instead of silently obeying either side. - Use Case: Before dispatching an autonomous agent on a research repository, run the required checks to confirm hooks are firing, the worktree has .env copied in, and the dispatch prompt states hard stops and the results/ provenance rule. ## Quick Start Review my current agent environment against the safety guardrails and confirm all enforcement hooks are active before I dispatch an autonomous task.

Frequently Asked Questions about tda-agent-safety-guardrails

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I prevent an AI agent from running destructive git commands?

Define blocking rules for `git push` to shared branches, `git reset --hard`, `git clean`, force-pushes, and `git commit --no-verify`. Require explicit user confirmation for these operations and record the reason when a blocked operation is genuinely necessary.

How do I verify git hooks are active before dispatching an autonomous agent?

Check that pre-commit contract gates, the sync gate, and commit-message prefix hooks fire on commit, and that write-time hooks like the notation guard and results no-overwrite hook are active. For worktrees, confirm `.env` was copied in and the branch follows the naming convention.

What should an autonomous agent dispatch prompt include for safety?

The prompt should bound scope with hard stops, state the blocking gates that apply, and repeat the results provenance rule that date-suffixed result files are immutable once written. This keeps the agent inside the same boundaries the hooks enforce mechanically.

When should a guardrail be overridden by a user instruction?

Never silently. When a guardrail conflicts with an explicit user instruction, surface the conflict and let the user decide, recording the reason. Bypassing a hook with `--no-verify` re-opens the exact gap the hook was created to close.

Why must contract files and their implementing code not change in the same task?

The contract-authorship split exists to stop a single unreviewed change from altering both the specification and its implementation together. Changing them in one task defeats independent verification, so the guardrails block it.