# Impl

> >

- **Type:** Skill
- **Install:** `agentstack add skill-jazz1x-harnish-impl`
- **Verified:** Pending review
- **Seller:** [jazz1x](https://agentstack.voostack.com/s/jazz1x)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [jazz1x](https://github.com/jazz1x)
- **Source:** https://github.com/jazz1x/harnish/tree/main/skills/impl
- **Website:** https://skills.sh/jazz1x/harnish

## Install

```sh
agentstack add skill-jazz1x-harnish-impl
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# impl — Autonomous Implementation Engine (the "harnish" engine)

> Do not judge. Follow the rules. When lost, return to harnish-current-work.json. When stuck, escalate. No invention.

## Skill Chain

```
drafti-architect (or drafti-feature) → impl → galmuri:ralphi (sibling plugin)
```

| Skill | Standalone Call | Prerequisites |
|-------|----------------|---------------|
| drafti-architect | Yes | None (only needs a technical problem) |
| drafti-feature | Yes | Requires a planning document |
| impl | Yes | docs/prd-*.md or existing harnish-current-work.json |
| galmuri:ralphi | Yes (external) | Specify target files/directories to verify |

When harnish starts without a PRD: "No PRD found. Please create one first with /drafti-architect or /drafti-feature."

## Bash Convention

> bash 3.2+, python3 (3.14+). macOS/Linux. No jq required as of v0.1.0.

Each Bash tool invocation is a fresh subshell — variables do **not** survive across calls. Every bash block in this skill must re-declare `HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"` inline before using any script path. There are no persistent script-name aliases; full paths (`$HARNISH_ROOT/scripts/{name}.sh`) are used directly.

State counters (`TASK_COMPLETE_COUNT`, etc.) are tracked by the LLM in conversation memory, not in shell variables. `COMPRESS_EVERY_N = 5`.

## Entry Check

If invoked with no context (no PRD path, no task description, no experience command, no `harnish-current-work.json` in CWD):
→ Ask: "무엇을 구현할까요? PRD 파일 경로나 작업 내용을 알려주세요."
→ Wait for user response before proceeding to Step 1.

## Step 1: Mode Detection

| Condition | Mode | Next | References to Load |
|-----------|------|------|--------------------|
| PRD provided, no harnish-current-work.json | Seeding | Step 2 | `task-schema.md` + `progress-template.md` |
| harnish-current-work.json exists | Implementation Loop | Step 3 | `escalation-protocol.md` + `guardrail-levels.md` |
| "자산 현황/압축/기억해/스킬로" | Experience | Step 5 | `thresholds.md` |
| harnish-current-work.json exists + session start | Restore | Step 4 | — |

Load **at most 2 references** at a time. (See Context Budget below.)

**Note**: `references/retention-policy.md` is **not** auto-loaded by any utterance — it documents an out-of-band ops flow (`scripts/purge-assets.sh`, asset deletion). It is referenced only on explicit `자산 보존 정책` / `asset retention policy` utterance per Step 5.

## Step 2: Seeding (PRD → harnish-current-work.json)

1. Verify PRD file: `docs/prd-{name}.md`. Confirm existence of §4 (Implementation Spec), §6 (Tests), §7 (Guardrails)
2. Query existing assets:
   ```bash
   HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
   bash "$HARNISH_ROOT/scripts/query-assets.sh" \
     --tags "{key}" --types guardrail --format text \
     --base-dir "$(pwd)/.harnish"
   ```
3. Phase splitting: Data → Business Logic → UI → Integration Tests
4. Task decomposition: **1 task = 1 file | 1 function | 1 test | 1 config**
5. Read `references/progress-template.md` and generate harnish-current-work.json → validate:
   ```bash
   HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
   bash "$HARNISH_ROOT/scripts/validate-progress.sh" .harnish/harnish-current-work.json
   ```
6. Report to user: "Seeding complete — {N} Phases, {M} Tasks — review and say 'run loop'"
7. → Proceed to Step 3

## Step 3: Implementation Loop (ralph)

### Entry

```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
bash "$HARNISH_ROOT/scripts/validate-progress.sh" .harnish/harnish-current-work.json
bash "$HARNISH_ROOT/scripts/loop-step.sh" .harnish/harnish-current-work.json
```
- `STATUS=ALL_DONE` → report completion → STOP
- `STATUS=NO_DOING` → move first Todo to Doing (see "Todo→Doing" below)
- `STATUS=ACTIVE` → check next action of current task → start loop

### One Loop Cycle = READ → ACT → LOG → PROGRESS

**[READ]**
- Read the doing task's objective, strategy, files, and prohibitions from harnish-current-work.json
- Query assets:
  ```bash
  HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
  bash "$HARNISH_ROOT/scripts/query-assets.sh" --tags "{task-id},{phase}" --format inject --base-dir "$(pwd)/.harnish"
  ```

**[ACT]**
- Create/modify files according to the guide
- Hard guardrail violation → immediately STOP + escalation
- Soft guardrail violation → warning + auto-correction

**[LOG]** (every 3 actions)
- Update harnish-current-work.json doing: current / last action / next action
- ```bash
  HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
  bash "$HARNISH_ROOT/scripts/validate-progress.sh" .harnish/harnish-current-work.json
  ```

**[PROGRESS]** Run acceptance_criteria:
- **Pass** → move Doing→Done → record asset (if applicable) → TASK_COMPLETE_COUNT += 1 → move next Todo→Doing → repeat loop
- **1-2 failures** → analyze cause → fix → go to [ACT]
- **3 failures** → record failure asset → **escalation. Do not attempt to resolve alone.**

### How to Run acceptance_criteria

| Form | Execution | Pass Criteria |
|------|-----------|---------------|
| bash command | Execute as-is | exit 0 |
| Condition list | Verify each condition in code | All ✓ |
| Mixed | bash first, then conditions | Both pass |
| None | **Escalation** (cannot mark Done without criteria) | — |

#### Behavior When acceptance_criteria Is Empty

The empty-criteria check is an **entry gate at every transition into Doing**, not a post-execution check:

1. **Seeding (Step 2)**: Extract criteria from PRD §6. If mapping is not possible → immediately ask the user: "Please specify acceptance_criteria for Task {id}." Do not seed the task without criteria.
2. **Todo→Doing transition**: If `acceptance_criteria` is empty or missing → escalate **before** transitioning to Doing. The task does not enter Doing.
3. **Mid-session edits**: If a task already in Doing has its criteria emptied (rare; usually a user manual edit) → escalate immediately on next loop entry, before [ACT]. This is separate from the 3-failure rule.

### Todo→Doing Transition

1. Check `.todo.phases[0].tasks[0]` (first incomplete task)
2. Verify `depends_on` is satisfied (all prerequisite Tasks exist in `.done.phases`)
3. Update harnish-current-work.json: `.doing.task = {id, title, started_at, current, next_action, blocker:null, retry_count:0, context}`, remove the task from `.todo`
4. Update `.metadata.status`
5. ```bash
   HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
   bash "$HARNISH_ROOT/scripts/validate-progress.sh" .harnish/harnish-current-work.json
   ```

### Doing→Done Transition

1. Find the same phase in `.done.phases` (add a new Phase if not found)
2. Add completed task: `{id, title, result: "one-line summary", files_changed, verification, duration}`
3. `.doing.task = null`, `.stats.completed_tasks += 1`
4. ```bash
   HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
   bash "$HARNISH_ROOT/scripts/validate-progress.sh" .harnish/harnish-current-work.json
   ```

### On Phase Completion (Milestone)

```
✅ Milestone: Phase {N} — {title}
Completed: {M} tasks / Changed: {K} files
Next: Phase {N+1} — Shall we continue?
```

Run RAG compression:
```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
bash "$HARNISH_ROOT/scripts/compress-progress.sh" .harnish/harnish-current-work.json --trigger milestone --phase {N}
```

Counter-based compression (LLM tracks `TASK_COMPLETE_COUNT` in conversation; every 5):
```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
bash "$HARNISH_ROOT/scripts/compress-progress.sh" .harnish/harnish-current-work.json --trigger count
```
Run the above only when `TASK_COMPLETE_COUNT % 5 == 0`. The decision to run is the LLM's; the bash invocation itself does not check the counter.

Wait for user response → "continue" → next Phase → repeat loop. All Phases Done → completion report.

### Escalation Report

```
🆘 Escalation: Task {ID} — {title}
Blocked at: {file/function/command}
Attempts: 1. {attempt}: {result} / 2. ... / 3. ...
Options: A. {A} / B. {B}
```

### Prohibited Mid-Loop

The only permitted stop points inside Step 3 are:
1. **Milestone HITL** — at phase boundary (see "On Phase Completion")
2. **Escalation** — 3 consecutive acceptance_criteria failures
3. **Hard guardrail violation** — see Guardrails

Any other interruption is prohibited — including but not limited to:
- Asking the user for permission to continue without a blocker
- Proposing a mid-phase summary/checkpoint due to context size or task count
- Stopping because "many tasks completed" without a defined phase boundary

Context fatigue is not a stop condition. If context is tight, rely on `compress-progress.sh` and continue.

## Step 4: Session Restore (Anchoring)

When harnish-current-work.json exists + new session starts:

```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
bash "$HARNISH_ROOT/scripts/validate-progress.sh" .harnish/harnish-current-work.json   # verify structure integrity
bash "$HARNISH_ROOT/scripts/loop-step.sh" .harnish/harnish-current-work.json            # extract coordinates
```

If Doing exists, resume from "next action" / otherwise first Todo Task. Report then → enter Step 3 loop:
   ```
   🔄 Session restored
   Current: Phase {N} / Task {ID} — {title}
   Next: {next_action}
   ```

## Step 5: Experience Accumulation

### Asset Recording Criteria

| Condition | Type | Required/Recommended |
|-----------|------|----------------------|
| Same error 2+ times AND resolved | failure | Required |
| User says "remember/record pattern" | Corresponding type | Required |
| User says "never do ~" | guardrail | Required |
| First-try success AND generalizable | pattern | Recommended |
| A vs B choice AND clear rationale | decision | Recommended |
| Same code structure 2+ times | snippet | Recommended |
| None of the above | — | Do not record |

Recording:
```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
bash "$HARNISH_ROOT/scripts/record-asset.sh" \
  --type {type} --tags "{task-id},{phase}" \
  --title "{one line}" --content "{content}" \
  --base-dir "$(pwd)/.harnish"
```

### Manual Triggers

| Utterance | Action |
|-----------|--------|
| "자산 현황" / "asset status" | check-thresholds.sh |
| "자산 압축" / "compress assets" | compress-assets.sh |
| "이 패턴 기억해" / "remember this pattern" | record-asset.sh --type pattern |
| "스킬로 만들어" / "make it a skill" | skillify.sh |
| "자산 품질" / "asset quality" | quality-gate.sh |
| "위반 확인" / "check violations" | check-violations.sh |
| "자산 보존 정책" / "asset retention policy" | references/retention-policy.md (read-only — purge-assets is invoked out-of-band via CLI/cron, not via skill utterance) |

## Step 6: Post-Completion Ceremony

Trigger: Todo empty AND no Doing AND `.metadata.ceremony_done` is false/missing.

Purpose: turn "all tasks done" into a deliberate closing beat — inspect, compress, summarize, suggest next — rather than a sudden STOP.

### 6.1 Automatic Inspection (read-only)

Invoke `galmuri:ralphi` (sibling plugin) on files changed since session start. Report findings inline. **DO NOT auto-fix** — fixing is a separate user trigger. If galmuri is not installed, skip this step and surface a one-line note ("galmuri not installed — skipping post-Done inspection").

```
📋 Post-Done inspection (galmuri:ralphi, read-only)
Files changed this session: {N}
Findings: {count by severity}
```

### 6.2 Asset Compression Check

Run compress-assets.sh with `--dry-run`. If any tag accumulated ≥ `COMPRESS_EVERY_N` (5) entries, **suggest** compression (do not auto-apply):

```bash
HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
bash "$HARNISH_ROOT/scripts/compress-assets.sh" --dry-run --all --base-dir "$(pwd)/.harnish"
```

### 6.3 Summary Generation

3-line summary:

```
✅ Session summary
Files changed: {count} ({short list})
Key decisions: {1-2 one-liners from .harnish/harnish-assets.jsonl recorded this session}
Suggested next: {e.g., galmuri:ralphi fix | deploy | handoff | sibling plugin invocation}
```

### 6.4 HITL Before Persist

> "Ceremony complete. Save session summary to `docs/session-{YYYY-MM-DD}.md`? (y / n / edit-slug)"

- `y` → save + set `.metadata.ceremony_done: true` → STOP
- `n` → set `.metadata.ceremony_done: true` → STOP without save
- `edit-slug` → ask for slug, then `y` path

### Prohibited in Step 6

- Auto-fixing galmuri:ralphi findings (report only)
- Auto-applying asset compression (suggest only)
- Modifying harnish-current-work.json beyond `.metadata.ceremony_done` (done object is frozen)
- Re-entering the ceremony on a session that already ran it (single-fire per session)

## Context Budget

| When | Reads |
|---|---|
| Step 1 (Mode Detection) | Mode-specific references only (max 2): see Mode Detection table |
| Step 2 (Seeding) | PRD file (`docs/prd-*.md`), `references/progress-template.md`, query-assets output |
| Step 3 [READ] | Current task fields from `harnish-current-work.json`, query-assets output (filtered by task tags) |
| Step 3 [ACT] | Files referenced by current task only — no exploration outside scope |
| Step 3 [LOG] | None (write-only) |
| Step 3 [PROGRESS] | Test outputs only |
| Step 4 (Restore) | `harnish-current-work.json`, no source code |
| Step 5 (Experience) | `references/thresholds.md`, asset query output |
| Step 6 (Post-Completion) | galmuri:ralphi output + compress-assets dry-run output + session assets |

`Load at most 2 references at a time.` Other references must wait for a phase switch.

## Guardrails

**Soft** (warning + correction):
- 100+ line file change → review task splitting
- Cannot declare Done without tests
- Cannot mark Done a task without acceptance_criteria
- Warning when modifying files outside current task scope

**Hard** (immediate STOP + escalation):
- DROP TABLE / DROP DATABASE prohibited
- Installing new packages not specified in PRD prohibited
- Inserting hardcoded secrets prohibited
- Unrelated refactoring of files outside scope prohibited
- Deleting harnish-current-work.json or directly modifying the done object prohibited
- Mid-loop interruption outside milestone HITL / 3-failure escalation / hard-guardrail violation prohibited

## Termination Conditions

- Todo is empty and no Doing → **Step 6 Post-Completion Ceremony** → after 6.4 HITL → STOP
- User says "stop" → record current state in harnish-current-work.json → STOP
- On session end →
  ```bash
  HARNISH_ROOT="${CLAUDE_PLUGIN_ROOT}"
  bash "$HARNISH_ROOT/scripts/check-violations.sh" .harnish/harnish-current-work.json
  ```

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [jazz1x](https://github.com/jazz1x)
- **Source:** [jazz1x/harnish](https://github.com/jazz1x/harnish)
- **License:** MIT
- **Homepage:** https://skills.sh/jazz1x/harnish

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-jazz1x-harnish-impl
- Seller: https://agentstack.voostack.com/s/jazz1x
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.