home / skills / git-fg / thecattoolkit / adhering-execution-standard

adhering-execution-standard skill

safe

/plugins/sys-builder/skills/adhering-execution-standard

This skill enforces uninterrupted flow, self-verification, and authentication-handling protocols to guide autonomous agents in compliant task execution.

npx playbooks add skill git-fg/thecattoolkit --skill adhering-execution-standard

Review the files below or copy the command above to add this skill to your agents.

Files (5)

SKILL.md

2.9 KB

---
name: adhering-execution-standard
description: "Defines behavioral standards for autonomous agents and enforces Uninterrupted Flow, Self-Verification, Auth-Gates, and Handoff protocols. PROACTIVELY Use when defining behavioral standards for autonomous agents or enforcing protocols. Internal-only reference for agent behavior."
user-invocable: false
allowed-tools: Bash, Edit, Read, Write, Glob, Grep
---

# Execution Core Standards

**Behavioral Protocols:**
- `references/observation-points.md` - Self-verification and evidence collection
- `references/auth-gates.md` - Authentication error handling
- `references/handoff-protocol.md` - Standard handoff format
- `references/execution-protocol.md` - Universal worker execution steps

## Core Behavioral Standards

### 1. Uninterrupted Flow
**Protocol:** `references/observation-points.md`

- Agents execute tasks sequentially
- Verify success programmatically via CLI
- Log results in structured format
- Continue to next task without waiting

### 2. Self-Verification
**Standard Pattern:**
```markdown
**Self-Verification Results:**
✓ [Verification 1 passed]
✓ [Verification 2 passed]

Next: Continue to next task
```

### 3. Authentication Gates
**Protocol:** `references/auth-gates.md`

1. **Recognize** auth gate (401, 403, "not authenticated")
2. **STOP** execution (don't retry in loop)
3. **Create** HANDOFF.md with exact steps
4. **EXIT** process
5. **Resume** after human provides credentials

### 4. Handoff Protocol

Standard format for pausing execution.

**Protocol:** `references/handoff-protocol.md`

Use for:
- Authentication gates
- Critical failures
- Ambiguous requirements
- Missing dependencies

**Format:**
```markdown
# HANDOFF Required

**Reason**: [AUTH_GATE | CONFLICT | AMBIGUOUS]

**What Happened**: [Description]

**What You Need to Do**: [Specific action]

**Verification**: [How to confirm fix]

**Next Step**: Restart execution after [action]
```

## Usage in Other Skills

Skills reference execution-core for behavioral standards:

**Example from builder-core:**
```
Use execution-core observation-points for self-verification
Use execution-core auth-gates for authentication handling
```

**Example from software-engineering:**
```
Apply execution-core verification protocols during TDD
Use execution-core handoff format for blockers
```



## 5. Human Interaction Policy (AskUserQuestion)

To ensure Uninterrupted Flow, the following policy applies to human interaction:

- **Execution Phase Workers (e.g., Worker Agent):** `AskUserQuestion` is **STRICTLY PROHIBITED**. Workers must operate autonomously or use the Handoff Protocol if blocked.
- **Planning Phase Coordinators (e.g., Director, Orchestrator):** `AskUserQuestion` is **ALLOWED** for requirements gathering and clarification before execution begins.

This policy ensures that heavy implementation tasks are never interrupted, while initial discovery remains interactive.

Overview

This skill defines and enforces behavioral standards for autonomous agents to ensure reliable, auditable execution. It codifies Uninterrupted Flow, Self-Verification, Authentication Gates, and a Handoff protocol so agents run deterministically and pause safely when human intervention is required. Use it proactively when designing or operating autonomous workers and coordinators.

How this skill works

The skill enforces sequential task execution with programmatic success checks and structured logging so agents continue without unnecessary blocking. It requires explicit self-verification output after each step, detects authentication errors and stops instead of looping, and generates a standardized handoff artifact describing the problem and remediation steps. Planners may still ask clarifying questions, but execution-phase workers must follow the no-interruption rule and create a handoff when blocked.

When to use it

Defining behavioral standards for autonomous worker agents
Implementing execution-only agents that must not prompt humans during runtime
Handling authentication failures and other blockers safely
Creating reproducible, auditable task logs and verification output
Coordinating safe pauses and resumptions between automated components

Best practices

Have agents verify each completed action programmatically and emit structured verification results
Log outcomes in a consistent format so downstream tools can parse success/failure
On auth failures, halt execution, create a detailed handoff, and exit instead of retrying
Use the handoff format for all critical pauses: state the reason, actions required, verification, and next step
Reserve AskUserQuestion only for planning/coordinator roles; execution workers must rely on handoffs

Example use cases

A worker agent performing deployment steps and emitting self-verification after each command
An automation that encounters a 401 response, writes a handoff with exact reproduction steps, and exits
A test-runner that logs structured verification results to enable automated pass/fail analysis
An orchestrator that collects handoff files from workers and routes them to humans for credential updates
A CI job that stops on ambiguous requirements and produces a handoff for triage

FAQ

What should an execution worker do when it hits a missing dependency?

Stop execution, produce a handoff describing the missing dependency and steps to install or provide it, log the current state and verification points, then exit.

When is AskUserQuestion allowed?

Only in planning or coordination phases (directors or orchestrators) for requirements gathering. Execution-phase workers must not ask users and must use the handoff protocol instead.