メニュー
HAR: Execute Plans.md tasks from single task to full parallel team run. Trigger: implement, execute, do everything, breezing, team run, parallel. Do NOT load for: planning, review, release, setup.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/maxwell2732/claudecode-research-harness-workflow --skill harness-workコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SOC 職業分類に基づく
SKILL.md を表示中
| name | harness-work |
| description | HAR: Execute Plans.md tasks from single task to full parallel team run. Trigger: implement, execute, do everything, breezing, team run, parallel. Do NOT load for: planning, review, release, setup. |
| description-en | HAR: Execute Plans.md tasks from single task to full parallel team run. Trigger: implement, execute, do everything, breezing, team run, parallel. Do NOT load for: planning, review, release, setup. |
| description-ja | HAR:Plans.md タスクを1件から全並列チーム実行まで担当。実装して、実行して、全部やって、breezing、チーム実行、parallel で起動。プランニング・レビュー・リリース・セットアップには使わない。 |
| kind | workflow |
| purpose | Execute Plans.md tasks end to end |
| trigger | implement, execute, do everything, breezing, team run, parallel |
| shape | workflow |
| role | executor |
| pair | harness-review |
| owner | harness-core |
| since | 2026-05-05 |
| allowed-tools | ["Read","Write","Edit","Grep","Glob","Bash","Task","Monitor"] |
| argument-hint | [all] [task-number|range] [--codex] [--parallel N] [--no-commit] [--resume id] [--breezing] [--auto-mode] [--tdd-bypass] |
| user-invocable | true |
| effort | high |
Integrated Harness execution skill. Consolidates the following legacy skills:
work — Plans.md task implementation (auto scope detection)impl — Feature implementation (task-based)breezing — Full team auto-executionparallel-workflows — Parallel workflow optimizationci — CI failure recovery| User input | Mode | Action |
|---|---|---|
/harness-work | auto | Auto-determined by task count (see below) |
/harness-work all | auto | Execute all incomplete tasks in auto mode |
/harness-work 3 | solo | Execute only task 3 immediately |
/harness-work --parallel 5 | parallel | Execute with 5 workers in parallel (forced) |
/harness-work --codex | codex | Delegate to Codex CLI (explicit only) |
| Cursor host (adapter candidate) | cursor | Task/subagent routing via .cursor/AGENTS.md; not auto-selected |
/harness-work --breezing | breezing | Force team execution |
/harness-work 3 --plan roadmap | solo | Execute task 3 from named plan roadmap |
When no explicit mode flag (--parallel, --breezing, --codex) is given,
the optimal mode is auto-selected based on the number of target tasks:
| Target tasks | Auto-selected mode | Reason |
|---|---|---|
| 1 | Solo | Minimal overhead; direct implementation is fastest |
| 2-3 | Parallel (Task tool) | Threshold where Worker isolation benefit starts to appear |
| 4+ | Breezing | Lead coordination + parallel Workers + independent Reviewer separation is effective |
--parallel N → Parallel mode (regardless of task count)--breezing → Breezing mode (regardless of task count)--codex → Codex mode (regardless of task count)--codex activates only when explicit. Not auto-selected because Codex CLI may not be installed.--codex can be combined with other modes: --codex --breezing → Codex + Breezing| Option | Description | Default |
|---|---|---|
all | Target all incomplete tasks | — |
N or N-M | Task number/range | — |
--parallel N | Number of parallel workers | auto |
--sequential | Force sequential execution | — |
--codex | Delegate implementation to Codex CLI (explicit only; not auto-selected) | false |
--plan NAME | Use named plan from plans/manifest.json | active/default |
--no-commit | Suppress auto-commit | false |
--resume <id|latest> | Resume previous session; use /recap together if a long time has passed | — |
--breezing | Team execution with Lead/Worker/Reviewer | false |
--no-tdd | Skip TDD phase | false |
--tdd-bypass | Bypass TDD enforcement in emergencies. Leave HARNESS_TDD_BYPASS_REASON or explicit reason in audit | false |
--no-simplify | Skip Auto-Refinement | false |
--auto-mode | Explicitly marks Harness-side Auto Mode rollout; different from --enable-auto-mode that became unnecessary in CC 2.1.111 | false |
Check only the entry point, auto-selection, and stop conditions in this body first. Read details only when needed.
| Details | Reference |
|---|---|
| Concrete procedures for Solo / Parallel / Codex / Breezing | references/execution-modes.md |
| Codex review, Reviewer fallback, AI Residuals, fix loop | references/review-loop.md |
| Solo / Breezing completion report generation | references/completion-report.md |
| Test/CI failure re-ticketing | references/failure-reticketing.md |
| Spec source of truth check criteria | docs/plans/spec-ssot.md |
Plans.md is in old format and DoD / Depends / Status cannot be read.${HARNESS_PLUGIN_ROOT}/scripts/, not from the host project's scripts/.--plan NAME and start a new run if needed.Token Optimization (v2.1.69+): For lightweight tasks without git operations, enable
includeGitInstructions: falsein plugin settings to reduce prompt tokens.
Prompt Cache (CC 2.1.108+): For longer implementations or work using
--resumefrequently, prioritizeENABLE_PROMPT_CACHING_1H=1.
/harness-work
How far should I go?
1) Next task: next incomplete task in Plans.md → Execute in Solo
2) All (recommended): complete all remaining tasks → Auto mode selection by task count
3) Specify number: enter task number (e.g., 3, 5-7) → Auto mode selection by count
When arguments are provided, execute immediately (skip dialog):
/harness-work all → all tasks, auto mode selection/harness-work 3-6 → 4 tasks, Breezing auto-selectedIn Claude Code v2.1.68, Opus 4.6 defaults to medium effort (◐).
In v2.1.72, max level was deprecated, simplified to 3 levels low(○)/medium(◐)/high(●).
Reset to default with /effort auto.
Enable high effort (●) for complex tasks with the ultrathink keyword.
xhigh was added in CC 2.1.111 for Opus 4.7.
You may stack /effort xhigh as a literal if needed.
At task start, sum the following scores and inject ultrathink when threshold ≥ 3:
| Factor | Condition | Score |
|---|---|---|
| File count | 4+ files to change | +1 |
| Directory | Includes core/, guardrails/, security/ | +1 |
| Keywords | Contains architecture, security, design, migration | +1 |
| Failure history | Same task failure record in agent memory | +2 |
| Explicit specification | ultrathink specified in PM template | +3 (auto-adopt) |
When score ≥ 3, prepend ultrathink to the Worker spawn prompt.
The same logic applies in breezing mode (managed centrally by harness-work).
Harness bundled helper scripts must always be called from the plugin bundle root, not from the target project's scripts/:
HARNESS_PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-}"
if [ -z "$HARNESS_PLUGIN_ROOT" ] && [ -n "${CLAUDE_SKILL_DIR:-}" ]; then
HARNESS_PLUGIN_ROOT="$(cd "${CLAUDE_SKILL_DIR}/../.." && pwd)"
fi
All subsequent node "${HARNESS_PLUGIN_ROOT}/scripts/..." / bash "${HARNESS_PLUGIN_ROOT}/scripts/..." assume this resolved root.
harness-plan create --ci → generate Plans.md and continuePlans.md is in old format. Please regenerate with harness-plan create. → Stopcc:TODO
git grep / Globdocs/spec/00-project-spec.md, docs/ARCHITECTURE.md, docs/HANDOFF.md, docs/oem/PROJECT_COMPASS.md, docs/specs/)docs/spec/00-project-spec.md if none existsspec_path or spec_skip_reason in context passed to Worker / Reviewercc:WIP[skip:tdd] and test framework exists):
a. Create test file first (Red)
b. Confirm failure
c. Leave FAIL evidence in .claude/state/tdd-red-log/<task-id>.jsonl with bash "${HARNESS_PLUGIN_ROOT}/scripts/log-tdd-red.sh". In environments where the script is unavailable, attach literal failing test output to self_review evidence in worker-report
d. When using --tdd-bypass, explicitly set HARNESS_TDD_BYPASS=1 and HARNESS_TDD_BYPASS_REASON="<reason>", and leave the reason for skipping TDD in sprint-contract / worker-reportsprint-contract.json with node "${HARNESS_PLUGIN_ROOT}/scripts/generate-sprint-contract.js" <task-id>bash "${HARNESS_PLUGIN_ROOT}/scripts/enrich-sprint-contract.sh" and confirm approved with bash "${HARNESS_PLUGIN_ROOT}/scripts/ensure-sprint-contract-ready.sh"needs-spike / security-sensitive / state-migration), consult once before first executionPIVOT_REQUIRED, consult once before stopping and escalating to useradvisor-response.v1: PLAN = restructure approach, CORRECTION = local fix, STOP = immediate escalationtrigger_hash. Maximum 3 consultations per task/simplify (skippable with --no-simplify)sprint-contract.json has reviewer_profile: runtime, run bash "${HARNESS_PLUGIN_ROOT}/scripts/run-contract-review-checks.sh"MAX_REVIEWS = read_contract(contract_path, ".review.max_iterations") or 3)bash "${HARNESS_PLUGIN_ROOT}/scripts/write-review-result.sh" (pass --browser-result for browser profile; adopt static verdict when browser_verdict == PENDING_BROWSER)git commit (skippable with --no-commit)cc:done (with commit hash)
git log --oneline -1cc:done [a1b2c3d] format--no-commit): cc:done without hash--parallel N)Execute tasks marked [P] with N workers in parallel.
When --parallel N is explicitly specified, use this mode regardless of task count.
Isolate with git worktree when same-file write conflicts occur.
--codex only)Delegate tasks to Codex CLI via the official plugin codex-plugin-cc companion:
# Task delegation (writable)
bash "${HARNESS_PLUGIN_ROOT}/scripts/codex-companion.sh" task --write "task content"
# Via stdin (for large prompts)
CODEX_PROMPT=$(mktemp /tmp/codex-prompt-XXXXXX.md)
cat "$CODEX_PROMPT" | bash "${HARNESS_PLUGIN_ROOT}/scripts/codex-companion.sh" task --write
rm -f "$CODEX_PROMPT"
# Continue previous thread
bash "${HARNESS_PLUGIN_ROOT}/scripts/codex-companion.sh" task --resume-last --write "continue"
Companion communicates with Codex via App Server Protocol, providing job management, thread resume, and structured output. Verify results; fix independently when quality criteria are not met.
On Cursor host, .cursor/AGENTS.md and .cursor-plugin/plugin.json are the bootstrap route. Cursor remains candidate — supported claims are prohibited.
.cursor/agents/worker.md subagentModel routing:
bash scripts/model-routing.sh --host cursor --role worker --format json
Explicit Task/subagent model takes priority over routed default.
Verification:
bash tests/test-cursor-adapter-candidate.sh
--breezing)Team execution with role separation: Lead / Worker / Advisor / Reviewer.
In Codex, assumes native subagent orchestration using spawn_agent, wait, send_input, resume_agent, close_agent — does not use the old TeamCreate/TaskCreate-based description.
In Cursor, maps to Task/subagent/background agents, but review/cherry-pick serial responsibilities remain on the core side (adapter smoke target).
Permission policy:
bypassPermissions--auto-mode is treated as an opt-in rollout flag for compatible parent sessionsautoMode value in permissions.defaultMode or agent frontmatter permissionModeCC v2.1.69+: Nested teammates are prohibited by the platform, so do not add redundant nested-prevention wording to Worker/Reviewer prompts.
Lead (this agent)
├── Worker (task-worker agent) — implementation
├── Advisor (claude-code-harness:advisor) — policy advice
└── Reviewer (code-reviewer agent) — review
Phase A: Pre-delegate (preparation):
sprint-contract.json with node "${HARNESS_PLUGIN_ROOT}/scripts/generate-sprint-contract.js"bash "${HARNESS_PLUGIN_ROOT}/scripts/enrich-sprint-contract.sh" and stop if not approved with bash "${HARNESS_PLUGIN_ROOT}/scripts/ensure-sprint-contract-ready.sh"Phase B: Delegate (Worker spawn → Advisor when needed → review → cherry-pick):
Execute the following sequentially for each task (in dependency order):
API note: Written in Claude Code API syntax below. In Codex environments, translate
Agent(...)→spawn_agent(...),SendMessage(...)→send_input(...). See API mapping table inteam-composition.mdfor details.
for task in execution_order:
# B-1. Generate sprint-contract
contract_path = bash("node \"${HARNESS_PLUGIN_ROOT}/scripts/generate-sprint-contract.js\" {task.number}")
contract_path = bash("bash \"${HARNESS_PLUGIN_ROOT}/scripts/enrich-sprint-contract.sh\" {contract_path} --check \"Verify DoD from reviewer perspective\" --approve")
bash("bash \"${HARNESS_PLUGIN_ROOT}/scripts/ensure-sprint-contract-ready.sh\" {contract_path}")
# B-2. Worker spawn (foreground, worktree isolated)
Plans.md: task.status = "cc:WIP" # Update on start (untouched tasks remain cc:TODO)
briefing_header = ""
if universal_violations:
briefing_header = (
"🚨 Universal violations already detected in this session (do not repeat):\n"
+ "\n".join(f"- {v}" for v in universal_violations)
+ "\n\n"
)
worker_result = Agent(
subagent_type="claude-code-harness:worker",
prompt=briefing_header + "Task: {task.content}\nDoD: {task.DoD}\ncontract_path: {contract_path}\nmode: breezing",
isolation="worktree",
run_in_background=false
)
worker_id = worker_result.agentId
# B-3. Lead calls Advisor only when Worker returns advice request
if worker_result.type == "advisor-request.v1":
advisor_result = Advisor(prompt=worker_result.request_json)
worker_result = SendMessage(to=worker_id, message="advisor-response.v1: {advisor_result}")
# B-3.5. self_review gate (Lead mechanically verifies before spawning Reviewer)
self_review_failures = 0
MAX_SELF_REVIEW_RETRIES = 2
while True:
unverified = [r for r in worker_result.self_review if (not r.get("verified")) or (not r.get("evidence"))]
if not unverified:
break
self_review_failures += 1
if self_review_failures > MAX_SELF_REVIEW_RETRIES:
Plans.md: task.status = "cc:TODO"
raise EscalationError(f"self_review not confirmed after 3 returns (rules: {[u['rule'] for u in unverified]})")
SendMessage(to=worker_id, message=f"self_review has unconfirmed rules: {[u['rule'] for u in unverified]}. Fill evidence for each rule with actual command output or literal test results, attach TDD evidence when required, set verified=true, then amend")
worker_result = wait_for_response(worker_id)
# B-4. Lead runs review (Codex exec priority)
diff_text = git("-C", worker_result.worktreePath, "show", worker_result.commit)
verdict = codex_exec_review(diff_text) or reviewer_agent_review(diff_text)
profile = jq(contract_path, ".review.reviewer_profile")
review_input = "review-output.json"
if profile == "runtime":
review_input = bash("cd {worker_result.worktreePath} && bash \"${HARNESS_PLUGIN_ROOT}/scripts/run-contract-review-checks.sh\" {contract_path}")
runtime_verdict = jq(review_input, ".verdict")
if runtime_verdict == "REQUEST_CHANGES":
verdict = "REQUEST_CHANGES"
elif runtime_verdict == "DOWNGRADE_TO_STATIC":
pass
browser_result = ""
if profile == "browser":
browser_artifact = bash("bash \"${HARNESS_PLUGIN_ROOT}/scripts/generate-browser-review-artifact.sh\" {contract_path}")
browser_result = bash("bash \"${HARNESS_PLUGIN_ROOT}/scripts/browser-review-runner.sh\" {browser_artifact}")
browser_verdict = jq(browser_result, ".browser_verdict")
if browser_verdict == "REQUEST_CHANGES":
verdict = "REQUEST_CHANGES"
elif browser_verdict == "APPROVE" and verdict != "REQUEST_CHANGES":
verdict = "APPROVE"
bash("bash \"${HARNESS_PLUGIN_ROOT}/scripts/write-review-result.sh\" {review_input} {latest_commit} --browser-result {browser_result}")
# B-5. Fix loop (on REQUEST_CHANGES, up to max_iterations from contract)
review_count = 0
MAX_REVIEWS = read_contract(contract_path, ".review.max_iterations") or 3
latest_commit = worker_result.commit
while verdict == "REQUEST_CHANGES" and review_count < MAX_REVIEWS:
SendMessage(to=worker_id, message="Findings: {issues}\nPlease fix and amend")
updated_result = wait_for_response(worker_id)
latest_commit = updated_result.commit
diff_text = git("-C", worker_result.worktreePath, "show", latest_commit)
verdict = codex_exec_review(diff_text) or reviewer_agent_review(diff_text)
review_count++
# B-6. APPROVE → cherry-pick to trunk (via feature branch)
if verdict == "APPROVE":
TRUNK=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's|refs/remotes/origin/||' || echo "main")
git checkout "$TRUNK"
if git("merge-base", "--is-ancestor", latest_commit, "HEAD"):
pass # Already on trunk — skip cherry-pick (re-entry prevention)
else:
git cherry-pick --no-commit {latest_commit}
git commit -m "{task.content}"
if worker_result.worktreePath:
git worktree remove {worker_result.worktreePath} --force
if worker_result.branch and worker_result.branch not in ["main", "master"] and worker_result.branch != TRUNK:
git branch -D {worker_result.branch}
Plans.md: task.status = "cc:done [{hash}]"
HASH=$(git rev-parse --short HEAD)
REVIEW_RESULT_PATH=".claude/state/review-results/${task.number}.review-result.json"
bash "${HARNESS_PLUGIN_ROOT}/scripts/auto-checkpoint.sh" \
"${task.number}" "${HASH}" "${contract_path}" "${REVIEW_RESULT_PATH}" \
|| true # fail-open: continue even in environments without harness-mem
else:
→ Escalate to user
# B-7. Progress feed
print("📊 Progress: Task {completed}/{total} done — {task.content}")
Advisor is neither "implementer" nor "reviewer." It is a consultation role that enters only when needed to help the executor decide the next step.
advisor-request.v1 only when neededPLAN / CORRECTION / STOPIn solo execution, the parent session serves as Lead. That is: "implement yourself, consult Advisor yourself, and then send to independent review at the end."
STOP stops there and escalates to usersprint-contract is a small contract file that makes "what this task needs to pass" readable in the same way by both machine and human.
Default location: .claude/state/contracts/<task-id>.sprint-contract.json
node "${HARNESS_PLUGIN_ROOT}/scripts/generate-sprint-contract.js" 32.1.1
Generated content includes:
checks: Verification items broken down from DoDnon_goals: What not to do this timeruntime_validation: Verification commands such as test, lint, typecheckbrowser_validation: UI flow verification items the browser reviewer should leavebrowser_mode: scripted or exploratoryroute: Which of playwright / agent-browser / chrome-devtools the browser reviewer usesrisk_flags: needs-spike, security-sensitive, ux-regression, etc.reviewer_profile: static, runtime, browserPhase C: Post-delegate (integration and reporting):
When CI fails:
When tests/CI fail after task completion, auto-generate a fix task proposal and reflect in Plans.md after approval:
| Condition | Action |
|---|---|
Test fails after cc:done | Save fix task proposal to state and wait for approval |
| CI failure (fewer than 3 times) | Apply fix and increment failure count |
| CI failure (3rd time) | Present fix task proposal + escalate |
.claude/state/pending-fix-proposals.jsonl:
.fix suffix (e.g., 26.1.fix)fix: [original task name] - [failure cause category]approve fix <task_id>, add to Plans.md as cc:TODOreject fix <task_id>. When only 1 pending item, yes / no also worksQuality verification stage that runs automatically after implementation (after step 5). Applied uniformly across all modes (Solo / Parallel / Breezing). In Parallel mode, each Worker runs the same loop as step 10 (external review acceptance).
1. Codex exec (priority)
↓ codex command not found or timeout (120s)
2. Internal Reviewer agent (fallback)
Pass the following threshold criteria to the reviewer and have it judge verdict by these criteria only.
Improvement suggestions outside the criteria are returned as recommendations but do not affect verdict.
| Severity | Definition | Verdict effect |
|---|---|---|
| critical | Security vulnerability, data loss risk, potential production incident | 1 or more → REQUEST_CHANGES |
| major | Existing feature breakage, clear spec conflict, test failure | 1 or more → REQUEST_CHANGES |
| minor | Naming improvement, missing comment, style inconsistency | No effect on verdict |
| recommendation | Best practice suggestion, future improvement | No effect on verdict |
Important: When only minor/recommendation, always return APPROVE. "Improvements that would be nice to have" are not a reason for REQUEST_CHANGES.
Save HEAD at task start as BASE_REF and use the diff from that ref as the review target.
Use the companion review of official plugin codex-plugin-cc.
# Record base ref at task start (run before cc:WIP update in Step 2)
BASE_REF=$(git rev-parse HEAD)
# ... after implementation ...
# Run structured review from official plugin
bash "${HARNESS_PLUGIN_ROOT}/scripts/codex-companion.sh" review --base "${BASE_REF}"
REVIEW_EXIT=$?
Verdict mapping (official plugin → Harness format):
| Official plugin | Harness | Verdict effect |
|---|---|---|
approve | APPROVE | — |
needs-attention | REQUEST_CHANGES | — |
findings[].severity: critical | critical_issues[] | 1 or more → REQUEST_CHANGES |
findings[].severity: high | major_issues[] | 1 or more → REQUEST_CHANGES |
findings[].severity: medium/low | recommendations[] | No effect on verdict |
AI Residuals scan continues to run with bash "${HARNESS_PLUGIN_ROOT}/scripts/review-ai-residuals.sh",
combined with companion review results to determine final verdict.
AI_RESIDUALS_JSON="$(bash "${HARNESS_PLUGIN_ROOT}/scripts/review-ai-residuals.sh" --base-ref "${BASE_REF}" --include-untracked 2>/dev/null || echo '{"tool":"review-ai-residuals","scan_mode":"diff","base_ref":null,"include_untracked":true,"files_scanned":[],"untracked_files_scanned":[],"summary":{"verdict":"APPROVE","major":0,"minor":0,"recommendation":0,"total":0},"observations":[]}')"
When Codex exec is unavailable (command -v codex fails or exit code ≠ 0):
Agent tool: subagent_type="reviewer"
prompt: "Please review the following changes. Criteria: critical/major → REQUEST_CHANGES; minor/recommendation only → APPROVE. diff: {git diff ${BASE_REF}}"
Reviewer agent runs safely in Read-only mode (Write/Edit/Bash disabled).
review_count = 0
contract_path = get_sprint_contract_path()
MAX_REVIEWS = read_contract(contract_path, ".review.max_iterations") or 3
while verdict == "REQUEST_CHANGES" and review_count < MAX_REVIEWS:
1. Parse review findings (critical / major only)
2. Implement fix for each finding
3. Run review again (same criteria, same priority)
review_count++
if review_count >= MAX_REVIEWS and verdict != "APPROVE":
→ Escalate to user
→ Show "Fixed MAX_REVIEWS times but following critical/major findings remain" + finding list
→ Wait for user decision (continue / abort)
In Breezing mode, Lead runs the review loop (see Phase B above):
MAX_REVIEWS = read_contract(contract_path, ".review.max_iterations") or 3 times)cc:done [{hash}]Visual summary auto-output at task completion (cc:done + after commit).
Intended to convey changes and impact to non-experts as well.
┌─────────────────────────────────────────────┐
│ ✓ Task {N} done: {task name} │
├─────────────────────────────────────────────┤
│ │
│ ■ What was done │
│ • {change 1} │
│ • {change 2} │
│ │
│ ■ What changed │
│ Before: {old behavior} │
│ After: {new behavior} │
│ │
│ ■ Changed files ({N} files) │
│ {file path 1} │
│ {file path 2} │
│ │
│ ■ Remaining issues │
│ • Task {X} ({status}): {content} ← Plans.md │
│ • Task {Y} ({status}): {content} ← Plans.md │
│ ({M} incomplete tasks in Plans.md) │
│ │
│ commit: {hash} | review: {APPROVE} │
└─────────────────────────────────────────────┘
git diff --stat HEAD~1 and commit message. Minimize jargon; start with a verb.git diff --name-only HEAD~1. Abbreviate with count when exceeding 5 files.cc:TODO / cc:WIP tasks from Plans.md. Explicitly note whether already in Plans.md.--parallel is forced): Use Solo templateOutput together after all tasks complete. List each task in abbreviated form (what was done + commit hash only), then output an overall summary (total changed files + remaining issues) at the end:
┌─────────────────────────────────────────────┐
│ ✓ Breezing done: {N}/{M} tasks │
├─────────────────────────────────────────────┤
│ │
│ 1. ✓ {task name 1} [{hash1}] │
│ 2. ✓ {task name 2} [{hash2}] │
│ 3. ✓ {task name 3} [{hash3}] │
│ │
│ ■ Overall changes │
│ {N} files changed, {A} insertions(+), │
│ {D} deletions(-) │
│ │
│ ■ Remaining issues │
│ {K} incomplete tasks in Plans.md │
│ • Task {X}: {content} │
│ │
└─────────────────────────────────────────────┘
harness-plan — Plan tasks to executeharness-sync — Sync implementation with Plans.mdharness-review — Review implementationharness-release — Version bump and release