Execute Phase

What it does

When your agent uses it

• The user says execute this plan
• Provides a plan path

Example prompts

• “execute this plan”
• “/execute-phase”

Requirements

• Docker
• Pre-approved tools (allowed-tools): Edit, Read, Write, Bash(git:*), Bash(python:*), Bash(pytest:*), Bash(mypy:*), Bash(black:*), Bash(coverage:*), Bash(docker:*), Bash(trivy:*), Bash(hadolint:*), Bash(jq:*), Bash(curl:*), Bash(gh:*)

Workflow steps

7 steps, taken from the step headings in SKILL.md.

1. 1Input
2. 2Read Plan & Lock Context
3. 3Pre-Flight Snapshot
4. 4Task-by-Task Execution
5. 5Quality Gates
6. 6Permalinks & Artifacts
7. 7Post-Deploy Verification (if applicable)

What it can do on your machine

Read from SKILL.md and the folder at commit 7a9fa15. It shows what the files ask for, not the result of running them.

• Tool permissions

  Pre-approves these tools, so the agent can use them without asking each time:

  • Edit
  • Read
  • Write
  • Bash(git:*)
  • Bash(python:*)
  • Bash(pytest:*)
  • Bash(mypy:*)
  • Bash(black:*)
  • Bash(coverage:*)
  • Bash(docker:*)

  …and 5 more on the same allowed-tools line.

  From allowed-tools in the SKILL.md frontmatter.

• Runs code

  Shell commands in SKILL.md call:

  • git
  • pytest
  • mypy
  • black
  • gh

  From the folder's file list and the shell code blocks in SKILL.md.

• Network

  No URLs in SKILL.md. Its commands use git and gh, which can reach the network depending on how they are called.

  From URLs in SKILL.md, links to its own repository left out.

• Credentials

  Names no API keys, tokens, secrets or passwords.

  From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Execute Phase loads about 1.8k tokens when it runs. Until then it costs about 74 tokens; SKILL.md has 400 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it

~74

When it runs · the whole SKILL.md, loaded when a task matches

~1.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from alchemiststudiosDOTai/harness-engineering at commit 7a9fa15, republished under its MIT licence (© alchemiststudiosDOTai). 400 words, ~1,798 tokens.

name

execute-phase

description

Execute implementation plans from .artifacts/plan/. Focus on EXECUTING ONLY - no planning, no fixes outside plan scope. Uses gated checks, atomic commits, and maintains a single execution log in .artifacts/execute/. Use when the user says "execute this plan" or provides a plan path.

allowed-tools

Edit, Read, Write, Bash(git:*), Bash(python:*), Bash(pytest:*), Bash(mypy:*), Bash(black:*), Bash(coverage:*), Bash(docker:*), Bash(trivy:*), Bash(hadolint:*), Bash(jq:*), Bash(curl:*), Bash(gh:*)

writes-to

.artifacts/execute/

hard-guards

NO planning - follow the plan exactly, NO fixes outside plan scope, Create rollback point before starting, Keep ONE execution log updated as you work, Commit…

# Capture git state
BRANCH=$(git branch --show-current)
SHA=$(git rev-parse --short HEAD)
STATUS=$(git status --short)

git add -A
git commit -m "rollback: before executing plan <topic>"

---
title: "<topic> execution log"
link: "<topic>-execute"
type: debug_history
ontological_relations:
  - relates_to: [[<plan-link>]]
tags: [execute, <topic>]
uuid: "<uuid>"
created_at: "<ISO-8601 timestamp>"
owner: "{{user}}"
plan_path: ".artifacts/plan/<file>.md"
start_commit: "<short_sha>"
env: {target: "local|staging|prod", notes: ""}
---

## Pre-Flight Checks
- Branch: <branch>
- Rollback commit: <sha>
- DoR satisfied: yes/no
- Access/secrets: present/missing
- Fixtures/data: ready/not ready

[If any NO → abort and add Blockers section]

1. Read task requirements
2. Implement minimal slice aligned with acceptance test
3. Run local validation
4. Commit atomic change with Task ID in message
5. Update execution log

T<NNN>: <task summary>

<brief description of change>

Refs: plan/<file>.md

# Run tests
pytest

# Type check
mypy src/

# Lint
black --check src/

# Coverage
coverage report

### Gate Results
- Tests: pass/fail + evidence
- Coverage: X% (target Y%)
- Type checks: pass/fail
- Linters: pass/fail

# Get repo info for permalinks
gh repo view --json owner,name

### Post-Deploy Verification
- Error rates: <metrics>
- Latencies: <metrics>
- Dashboard links: <URLs>
- Smoke/E2E results: <pass/fail>

---
title: "<topic> execution log"
link: "<topic>-execute"
type: debug_history
ontological_relations:
  - relates_to: [[<plan-link>]]
tags: [execute, <topic>]
uuid: "<uuid>"
created_at: "<ISO-8601 timestamp>"
plan_path: ".artifacts/plan/<file>.md"
start_commit: "<sha>"
end_commit: "<sha>"
env: {target: "...", notes: "..."}
---

## Pre-Flight Checks
- Branch: <branch>
- Rollback: <commit_sha>
- DoR: satisfied/not
- Ready: yes/no

## Task Execution

### T001 – <Summary>
- Status: completed/skipped/failed
- Commit: <sha>
- Files: <list>
- Commands: <cmd> → <output>
- Tests: pass/fail
- Coverage delta: +X%
- Notes: <decisions made>

### T002 – <Summary>
[... repeat for each task ...]

## Gate Results
- Tests: X/Y passed
- Coverage: X% (target Y%)
- Type checks: pass/fail
- Security: # issues
- Linters: pass/fail

## Deployment (if applicable)
- Staging: success/fail
- Prod: success/fail
- Timestamps: <start> → <end>

## Issues & Resolutions
- T<NNN> – <issue> → <resolution|rollback|asked user>

## Success Criteria
- [ ] All planned gates passed
- [ ] Rollout completed or rolled back
- [ ] KPIs/SLOs within thresholds
- [ ] Execution log saved

## Next Steps
- Follow-ups, tech debt, docs

# Execution Report – <topic>

**Date:** {{date}}
**Plan:** <plan_file>
**Log:** <log_file>

## Overview
- Environment: <env>
- Start: <sha>
- End: <sha>
- Duration: Xh Ym
- Branch: <branch>

## Outcomes
- Tasks attempted: N
- Tasks completed: N
- Final status: Success | Failure | Blocked

## Gate Results
- Tests: pass/fail
- Coverage: X% (target Y%)
- Type checks: pass/fail
- Security: # issues

## What Was Touched
[List all files modified]

## Next Steps
- [ ] Item 1
- [ ] Item 2

Executing plan: .artifacts/plan/<file>.md
Branch: <branch>
Rollback point: <commit_sha>
Tasks: N
Milestones: M

Execution complete: Success | Failure | Blocked
Tasks completed: N/N
Log: .artifacts/execute/<file>.md
Next step: QA from execute using the generated execution log path

© alchemiststudiosDOTai, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/execute-phase of alchemiststudiosDOTai/harness-engineering.

Open the folder on GitHubat commit 7a9fa15