work

Work Skill

Implement tasks from Plans.mdMain skill. Automatically selects a strategy based on scope.

Philosophy

"Ask, decide, and execute"

If it's 1 task, implement directly. If multiple, run in parallel. If many, auto-iterate. The user only needs to decide the scope; the rest is automatic.

Quick Reference

/work                    # スコープを聞いてから実行
/work 3                  # タスク3だけ即実行
/work all                # 全タスクを即実行
/work 3-6                # タスク3〜6を即実行
/work --codex            # Codex CLI で実装（スコープを聞く）
/work --codex all        # Codex CLI で全タスク即実行
/work --parallel 5       # 並列5ワーカーで実行
/work --no-commit        # 自動コミット抑制
/work --resume latest    # 前回セッション再開

Options

Option	Description	Default
`all`	Target all incomplete tasks	-
`N` or `N-M`	Specify task number/range	-
`--codex`	Delegate implementation to Codex CLI	false
`--parallel N`	Number of parallel workers	auto
`--sequential`	Disable parallelism (serial execution)	-
`--no-commit`	Suppress auto-commit	false
`--max-iterations N`	Iteration limit (when all)	10
`--resume <id\|latest>`	Resume session	-
`--fork <id\|current>`	Session fork	-
`--deep-simplify`	`/simplify` + `code-simplifier` Run both	false
`--no-simplify`	Skip Auto-Refinement	false

Scope Dialog (when no arguments)

When called with no arguments, confirm the scope interactively:

/work
どこまでやりますか?
1) 次のタスク (推奨): Plans.md の次の未完了タスク
2) 全部: 残りのタスクを全て完了
3) 指定: タスク番号や範囲を指定 (例: 3, 3-6)

> [Enter = 1]

If arguments are provided, execute immediately (skip the dialog).

Details: references/scope-dialog.md

Auto Strategy Selection

Automatically select an internal strategy based on scope:

Scope	Strategy	Equivalent to original skill
1 task	Direct implementation	Old `/work`
2-3 tasks	Sub-agent parallel	Old `/work --parallel`
4+ tasks or `all`	Sub-agent parallel + auto-iteration	Old `/ultrawork`

実行開始時に戦略を表示:

🔧 戦略: 直接実装 (タスク1件)
🔧 戦略: 並列 3 ワーカー (タスク3件)
🔧 戦略: 並列 3 ワーカー + 自動反復 (タスク8件, 最大10回)

The user does not need to be aware of the strategy.

Default Flow

/work [scope]
    ↓
Phase 0: スコープ確認 (引数なしなら対話)
    ↓
Phase 1: 戦略選択 (タスク数で自動判断)
    ↓
Phase 2: 実装
    → 1タスク: 直接実装
    → 複数: task-worker サブエージェント並列
    → 全部/4+: 並列 + 反復ループ (完了まで自動)
    ↓
Phase 3: Review Loop (harness-review)
    → APPROVE: proceed
    → REQUEST_CHANGES: fix → re-review
    ↓
Phase 3.5: Auto-Refinement
    → Default: run /simplify (bundled)
    → --deep-simplify: run /simplify then code-simplifier agent
    → --no-simplify: skip
    ↓
Phase 4: Auto-commit (unless --no-commit)
    ↓
Tip 表示

Unified Memory Gate (required)

/work When executing, always pass through Unified Harness Memory in the following order:

Before implementation: harness_mem_resume_pack(project, session_id?, limit=5, include_private=false)
When a milestone is reached (design finalized, major revision, direction change): harness_mem_record_checkpoint(session_id, title, content, tags?, privacy_tags?)
When implementation is complete (before handoff): harness_mem_finalize_session(session_id, summary_mode="standard")

Notes:

session_id は $CLAUDE_SESSION_ID → .claude/state/session.json の .session_id Retrieve in the order of
harness_mem_sessions_list(project, limit=1) The first use of is limited to read-only (resume confirmation), andrecord_checkpoint / finalize_session is explicitly session_id If there is no , treat it as a failure
In Codex, notify Use the hook (after_agent) together with this procedure to reduce missed recordings
.codex/history.jsonl is automatically ingested on the daemon side, so manual appending is unnecessary
If any of them fails, check the status with harness_mem_health() と scripts/harness-memd doctor and re-execute the same step after recovery

Auto-Iteration (4+ tasks or `all`)

When there are many tasks, the automatic iteration logic is enabled:

Self-learn from the previous failure
Retry incomplete tasks in the next iteration
Completion conditions: all tasks cc:done + build success + tests pass + Review APPROVE
Maximum number of iterations: --max-iterations (default: 10)

Details: references/auto-iteration.md

--codex Engine

--codex Delegate all implementation to Codex CLI with the flag:

Item	Default	--codex
Implementation owner	Claude (direct coding)	Codex CLI
Claude's role	Coordination + implementation	PM (coordination only)
Edit/Write	Allowed	Forbidden (guard applied)
Quality assurance	Self-review	AGENTS_SUMMARY + Quality Gates

Details: references/codex-engine.md

Feature Details

Feature	Reference
Scope Dialog	See references/scope-dialog.md
Auto-Iteration	See references/auto-iteration.md
Codex Engine	See references/codex-engine.md
Execution Flow	See references/execution-flow.md
Parallel Execution	See references/parallel-execution.md
Session Management	See references/session-management.md
Review Loop	See references/review-loop.md
Auto-commit	See references/auto-commit.md
Error Handling	See references/error-handling.md

Smart Parallel Detection

Condition	Parallel Count
1 task	1
All tasks edit same file	1
2-3 independent tasks	2-3
4+ independent tasks	3 (max)

Completion Tip

Guide next actions on completion:

Done! 2 tasks completed. (3 remaining)
Tip: /breezing でチーム並列実行できます
Tip: --codex を付けると Codex に実装を委託できます

Session State

Initialization

# work-active.json を作成
cat > .claude/state/work-active.json <<EOF
{
  "active": true,
  "started_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "strategy": "iteration",
  "codex_mode": false,
  "simplify_mode": "default",
  "bypass_guards": ["rm_rf", "git_push"],
  "allowed_rm_paths": ["node_modules", "dist", ".next", ".cache"],
  "review_status": "pending"
}
EOF

Clear on completion

rm -f .claude/state/work-active.json

Auto-invoke Skills

Skill	Purpose	When to Call
`impl`	Feature implementation	On task implementation
`verify`	Build verification	On post-implementation verification
`harness-review`	Multi-perspective review	After implementation complete

Project Configuration

Override defaults via .claude-code-harness.config.yaml:

work:
  auto_commit: false          # Disable auto-commit
  commit_on_pm_approve: true  # 2-Agent: defer commit until PM approves

VibeCoder Hints

What You Want	How to Say
Only the next task	`/work` (next task with Enter)
Finish everything	`/work all`
Only this number	`/work 3`
From here to here	`/work 3-6`
Leave it to Codex	`/work --codex`
Go faster in parallel	`/work --parallel 5 all`
Complete as a team	→ `/breezing` use

Related Skills

breezing - Team parallel completion with Agent Teams (Lead only directs)
harness-review - Code review (auto-started within /work)
impl - Implementation logic for individual tasks