claws-code 0.8.0

package/.claude/commands/claws.md

@@ -0,0 +1,64 @@
+---
+name: claws
+description: Master command for Claws terminal orchestration. Shows live status or routes to /claws-do.
+---
+
+## MANDATORY cold-start sequence — execute in order, no deliberation
+
+1. **Acknowledge in 1 line.** "Got it — <one-sentence task summary>." No more.
+2. **Do NOT enter plan mode.** This is an ACTION command. If the task is complex
+   enough to need a plan, redirect to `/claws-plan` and stop.
+3. **Do NOT call TodoWrite for the task itself.** Single-MCP-call command.
+4. **Do NOT pre-verify the sidecar, Monitor, or hooks.** Guaranteed by
+   SessionStart in v0.7.13+. Trust the system.
+5. **Classify the task in 1 sentence.** If you cannot, default to Bucket 2
+   (single worker via `claws_worker`).
+6. **Make the spawn call IMMEDIATELY.** ONE MCP tool call. No prelude.
+7. **Use the `monitor_arm_command` from the spawn response verbatim.** This MUST
+   be the very next tool call after the spawn returns. Any other tool call
+   between the spawn and the Monitor arming is a bug — abort and arm the
+   Monitor first. (This is Bug 6 Layer 0 — server-side enforcement coming in
+   Layers 1+2.)
+8. **Wait. Don't poll.** When Monitor returns, read output, report, close
+   terminal.
+
+If a PreToolUse hook denies a call, READ the error message — it tells you what's
+wrong. Don't loop or work around. Almost always: sidecar missing, advise user
+to reload VS Code rather than trying to start it manually.
+
+If you find yourself deliberating between steps, you've already failed cold
+start. Just classify and act.
+
+---
+
+# /claws [task]
+
+## What this does
+Context-aware master command. With no arguments it shows a live dashboard of all active terminals and the Claws version. With arguments it forwards the request to /claws-do so you never need to remember which command to use.
+
+## Behavior
+
+**No arguments — show status dashboard:**
+- Call `claws_list` to enumerate all active terminals
+- Read the first version line from CHANGELOG.md for the Claws version
+- Format terminals as a table: ID | Name | Wrapped | PID
+- End with: "Type /claws-do '<task>' to do anything. /claws-help for the full reference."
+
+**If `.claws/claws.sock` is absent:**
+- "Claws is not active. Reload VS Code: Cmd+Shift+P → Developer: Reload Window."
+- If `~/.claws-src` is missing: "Claws is not installed — contact your project owner."
+
+**With arguments:**
+- Treat the arguments as a task and execute /claws-do behavior directly.
+- Do not ask clarifying questions — classify and act.
+
+## Examples
+```
+/claws
+/claws fix the failing test in auth.test.ts
+/claws run npm test and show me the output
+```
+
+## When NOT to use
+If you want the full command reference, use /claws-help.
+If you want to close terminals, use /claws-cleanup.

package/.claude/rules/claws-default-behavior.md

@@ -0,0 +1,76 @@
+> **Scope note**: This file is loaded by the ECC plugin's `SessionStart` hook as a system-reminder.
+> It is NOT auto-loaded by stock Claude Code. The canonical imperative rules that every Claude
+> session sees are in the `CLAWS:BEGIN` block injected into `CLAUDE.md` by `scripts/inject-claude-md.js`.
+> This file is a supplement for ECC users — do not rely on it as the sole enforcement layer.
+
+---
+
+# Claws — Terminal Behavior Override
+
+> Auto-installed by Claws. This rule OVERRIDES default terminal behavior.
+
+## Never block the orchestrator
+
+`claws_fleet` and `claws_worker` are **non-blocking by default** — they spawn terminals and return `terminal_ids` within seconds. The MCP stdio transport cannot safely hold a response open for more than a few seconds; blocking the socket stalls the entire orchestrator session. Always fire-and-return, then poll completion via `claws_workers_wait` or by reading `.local/audits/` files on disk. Blocking modes (`wait:true` / `detach:false`) are opt-in and flagged unsafe.
+
+## MANDATORY: when the user invokes any /claws command, you MUST use Claws terminals
+
+When the user types `/claws-do`, `/claws-go`, or any `/claws-*` command, you are REQUIRED to create visible terminals via the Claws socket. Do NOT fall back to the Bash tool. Do NOT say "this isn't a Claws task." EVERYTHING asked through a /claws command IS a Claws task.
+
+**If MCP tools (claws_list, claws_create, etc.) are available**: use them directly.
+
+**If MCP tools are NOT loaded** (new session, MCP not registered): use raw socket calls via `node -e` with `require('net').createConnection('.claws/claws.sock')`. The socket commands are documented in every /claws-* slash command file.
+
+**If the socket doesn't exist**: tell the user to reload VS Code (Cmd+Shift+P → Developer: Reload Window).
+
+## For all other work (no /claws prefix), use this behavior:
+
+**DO**: run visible work in Claws terminals — builds, tests, deploys, servers, AI workers, refactoring, audits. The user watches it happen live in their VS Code terminal panel.
+
+**DO**: use `claws_worker` when the user asks to "fix", "refactor", "audit", or any complex task. This spawns a Claude Code session with full permissions that the user can watch.
+
+**DO**: spawn parallel terminals for independent tasks. "lint + test + build" = 3 terminals, all running simultaneously.
+
+**DO**: always create wrapped terminals (`wrapped=true`). Always close them when done.
+
+**USE BASH DIRECTLY FOR**: quick lookups — `ls`, `cat`, `git status`, `grep`, file reads. No terminal needed.
+
+## Pattern matching — what the user says → what you do
+
+"run tests" / "run the build" / "lint the code"
+→ `claws_create` wrapped → `claws_send` the command → `claws_read_log` → report → `claws_close`
+
+"run lint, test, and build" / "do these in parallel"
+→ 3x `claws_create` → send all 3 commands → monitor all 3 → close all → aggregate report
+
+"fix the bug" / "refactor this" / "audit the code" / "write tests for X"
+→ `claws_worker` with the mission → monitor via `claws_read_log` → report → close
+
+"start the server" / "watch for crashes"
+→ `claws_create` wrapped → send start command → monitor → restart if crash detected
+
+"spawn a worker" / "launch claude in a terminal"
+→ `claws_worker` — auto-launches Claude Code with `--dangerously-skip-permissions`
+
+"what's running" / "show me the terminals"
+→ `claws_list` → format as dashboard
+
+"clean up" / "close the workers"
+→ `claws_list` → close all worker terminals → confirm
+
+## Terminal naming
+
+Always descriptive: `worker-tests`, `worker-lint`, `build-server`, `ai-refactor`, `deploy-staging`.
+Never generic: `terminal`, `shell`, `worker-1`.
+
+## Cleanup is non-negotiable
+
+Every `claws_create` must have a matching `claws_close`. At the end of any orchestration, run `claws_list` and close anything you own that's still open. Stale terminals are a bug.
+
+## Never headless
+
+When spawning Claude Code in a worker terminal:
+- ALWAYS: `claude --dangerously-skip-permissions` (interactive, visible TUI)
+- NEVER: `claude -p "..."` (headless, invisible)
+
+The user must see every AI worker in their terminal panel.

package/.claude/settings.json

@@ -0,0 +1,112 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "permissions": {
+    "allow": [
+      "Read",
+      "Write",
+      "Edit",
+      "MultiEdit",
+      "Bash",
+      "Glob",
+      "Grep"
+    ]
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "_source": "claws-dev-hooks",
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/Desktop/Claws/.claws-bin/dev-hooks/check-stale-main.js\""
+          }
+        ]
+      },
+      {
+        "_source": "claws-dev-hooks",
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/Desktop/Claws/.claws-bin/dev-hooks/check-extension-dirs.js\""
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "_source": "claws-dev-hooks",
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/Desktop/Claws/.claws-bin/dev-hooks/check-tag-pushed.js\""
+          }
+        ]
+      },
+      {
+        "_source": "claws-dev-hooks",
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/Desktop/Claws/.claws-bin/dev-hooks/check-tag-vs-main.js\""
+          }
+        ]
+      },
+      {
+        "_source": "claws",
+        "matcher": "mcp__claws__claws_create",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/.claws-src/scripts/hooks/post-tool-use-claws.js\""
+          }
+        ]
+      },
+      {
+        "_source": "claws",
+        "matcher": "mcp__claws__claws_worker",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/.claws-src/scripts/hooks/post-tool-use-claws.js\""
+          }
+        ]
+      },
+      {
+        "_source": "claws",
+        "matcher": "mcp__claws__claws_fleet",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/.claws-src/scripts/hooks/post-tool-use-claws.js\""
+          }
+        ]
+      },
+      {
+        "_source": "claws",
+        "matcher": "mcp__claws__claws_dispatch_subworker",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/.claws-src/scripts/hooks/post-tool-use-claws.js\""
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "_source": "claws-dev-hooks",
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"/Users/ANISH.NEUNAHA/Desktop/Claws/.claws-bin/dev-hooks/check-open-claws-terminals.js\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/.claude/settings.local.json

@@ -0,0 +1,19 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//Users/ANISH.NEUNAHA/.claude/**)",
+      "Bash(git checkout *)",
+      "Bash(HOME=/tmp/claws-verify-fakehome rm -rf /tmp/claws-verify-fakehome)",
+      "Bash(mkdir -p /tmp/claws-verify-fakehome/.claude)",
+      "Bash(HOME=/tmp/claws-verify-fakehome node /Users/ANISH.NEUNAHA/Desktop/Claws/scripts/inject-settings-hooks.js)",
+      "Read(//tmp/claws-verify-fakehome/.claude/**)",
+      "Bash(mv /Users/ANISH.NEUNAHA/.vscode/extensions/neunaha.claws-0.7.2 /Users/ANISH.NEUNAHA/.vscode/extensions/neunaha.claws-0.7.3)",
+      "Read(//Users/ANISH.NEUNAHA/.vscode/extensions/**)",
+      "Bash(node -e \"console.log\\(require\\('/Users/ANISH.NEUNAHA/.vscode/extensions/neunaha.claws-0.7.3/package.json'\\).version\\)\")",
+      "Bash(node -e ' *)"
+    ]
+  },
+  "enabledMcpjsonServers": [
+    "claws"
+  ]
+}

package/.claude/skills/claws-auto-engine/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: claws-auto-engine
+description: Autonomous orchestration loop engine used by /claws-auto. Wave dispatch, inter-wave audit, failure recovery, time-budget tracking.
+type: skill
+---
+
+# Skill: claws-auto-engine
+
+The engine that powers `/claws-auto`. Describes the wave loop, dispatch protocol, inter-wave audit, failure recovery, and budget tracking.
+
+## Wave loop (top-level algorithm)
+
+```
+startedAt = now()
+waveNum   = 1
+budget    = { maxWaves: 6, maxMinutes: 90 }
+
+while not goalMet and not budgetExhausted:
+  workers = planWave(waveNum, goalState)          // max 4 workers
+  results = dispatchAndWait(workers)              // see dispatch protocol
+  goalState = auditWave(results)                  // inter-wave audit
+  updateProgress(waveNum, goalState)              // write PROGRESS.md
+  if hasFatalFailure(results): recoverOrSurface() // at most 1 recovery wave
+  waveNum++
+  budgetExhausted = (waveNum > budget.maxWaves)
+                 or (elapsedMin() > budget.maxMinutes)
+
+writeFinalSection(goalState)   // DONE or BLOCKED section in PROGRESS.md
+```
+
+## Dispatch protocol
+
+For each worker in a wave:
+1. `claws_worker(name=..., mission=..., detach=true)` → response includes `terminal_id` + `monitor_arm_command`
+2. `Monitor(command=response.monitor_arm_command, ...)` — MUST be the very next tool call after step 1
+3. After all dispatches + arms: wait for all Monitors to return (all workers signal completion)
+4. `claws_close(id)` for any terminal that did not auto-close
+
+**Max concurrent workers per wave: 4.** Exceeding this limit is a hard violation.
+
+## Mission constraints (enforced every wave)
+
+- Mission text < 500 words (`[[Compact missions]]`)
+- No literal completion marker in mission body (`[[Don't put literal marker in mission]]`)
+- Code-touching missions include: "this change must work identically on darwin, linux, and win32" (`[[Tri-platform first]]`)
+- Workers that push must `git pull --rebase origin <branch>` before push
+
+## Inter-wave audit
+
+After every wave, before planning the next:
+1. Read `.claws/events.log` for any ERROR events from workers
+2. Read worker pty logs (via `claws_read_log`) for failure signals if any worker did not complete cleanly
+3. Check that expected commits landed: `git log --oneline -10`
+4. Run `npx tsc --noEmit` if any `.ts` files were edited
+5. Write audit summary to `PROGRESS.md` under the completed wave
+
+Audit is synchronous and non-blocking — do NOT ask the user to confirm.
+
+## Failure recovery protocol
+
+On wave failure:
+1. Classify: is this a **transient** failure (network, timing) or a **structural** failure (design ambiguity, missing credentials)?
+2. **Transient**: spawn a recovery wave (max 1 recovery per original wave) that targets only the failed worker's scope
+3. **Structural**: surface to user with a specific question and the evidence trail from the logs
+4. Log the failure + recovery attempt in `PROGRESS.md`
+
+Never silently swallow a failure. Every ERROR event must appear in `PROGRESS.md`.
+
+## PROGRESS.md structure
+
+```markdown
+# Auto run: <goal>
+**Started**: ISO-8601  **Budget**: 6 waves / 90 min
+
+## Wave 1 — <name>
+**Dispatched**: <worker names>
+**Result**: green | partial | failed
+**Commits**: <git log --oneline output>
+**Audit notes**: <key findings>
+
+## Wave 2 — ...
+
+## DONE / BLOCKED
+<summary of outcome>
+```
+
+## Time-budget tracking
+
+Track elapsed time from `startedAt`. At each inter-wave audit:
+- If `elapsedMin() > 75`: warn in `PROGRESS.md` — "approaching budget, will stop after this wave"
+- If `elapsedMin() > 90` OR `waveNum > 6`: write BLOCKED section and stop
+
+## References
+
+- `.claude/commands/claws-auto.md` — the slash command that invokes this skill
+- `.claude/skills/claws-wave-lead/SKILL.md` — LEAD dispatch protocol (used for Bucket 4 waves)
+- `.claude/skills/claws-prompt-templates/SKILL.md` — mission text patterns

package/.claude/skills/claws-goal-tracker/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: claws-goal-tracker
+description: Goal decomposition + tracking skill used by /claws-goal. Breakdown heuristics, clarifying-question pattern, task-status protocol.
+type: skill
+---
+
+# Skill: claws-goal-tracker
+
+The engine that powers `/claws-goal`. Describes how to decompose a goal, when to ask clarifying questions, and how to manage task status throughout execution.
+
+## Goal classification
+
+Classify every incoming goal into one of these types before decomposing:
+
+| Type | Signals | Typical subtask count |
+|------|---------|----------------------|
+| bug-fix | "fix", "broken", "regression", error trace | 3–5 |
+| feature | "add", "implement", "build", "support" | 4–7 |
+| refactor | "clean up", "restructure", "extract", "rename" | 3–5 |
+| release | "ship", "publish", "tag", "release" | 5–7 |
+| audit | "audit", "review", "analyse", "check all" | 3–5 |
+| docs | "document", "update README", "write guide" | 3–4 |
+
+If the goal spans two types, pick the dominant one and note the secondary in the root task description.
+
+## Decomposition heuristics
+
+Break the goal into 3–7 subtasks. Each subtask must be:
+- **Atomic** — completable in one work session without sub-decomposition
+- **Verifiable** — has a clear done-signal (tests green, file exists, command exits 0)
+- **Scoped** — touches a named file, module, or output
+
+Prefer this ordering:
+1. Read/understand first (if needed) — no edits
+2. Prerequisite changes (types, schemas, config) before consumer changes
+3. Core implementation
+4. Tests — write before or alongside core (TDD preferred)
+5. Documentation / changelog (if required)
+6. Smoke/validation step last
+
+**Never** create a subtask like "do the rest" or "clean up" — be specific.
+
+## Clarifying-question pattern
+
+Ask clarifying questions ONLY when both conditions are true:
+- The scope cannot be determined from the goal text + reading the codebase
+- Two or more valid approaches exist with meaningfully different file or API surfaces
+
+Format: numbered list, one sentence each. Example:
+```
+Two things to clarify before I start:
+1. Should the WebSocket transport run alongside the Unix socket, or replace it?
+2. Is token auth required in this phase, or deferred to Phase 4?
+```
+
+Absolute cap: 2 questions. If you need more than 2, you're over-scoping — narrow the goal first.
+
+After the user answers (or if no questions are needed), begin Subtask 1 immediately.
+
+## Task-status protocol
+
+Every subtask follows this lifecycle:
+
+```
+pending → in_progress → completed
+                    ↓
+                 blocked (if question needed)
+                    ↓
+             in_progress (after user answers)
+```
+
+Tool calls:
+- `TaskCreate(title=..., status="pending")` — on decomposition
+- `TaskUpdate(id=..., status="in_progress")` — when you start the subtask
+- `TaskUpdate(id=..., status="completed", notes="<one-line summary>")` — when done and verified
+- `TaskUpdate(id=..., status="blocked", notes="<specific question>")` — when blocked
+
+Never mark a subtask `completed` before verification (tests pass, no type errors).
+
+## User checkpoint protocol
+
+Pause for user confirmation before moving to the next subtask when the completed subtask:
+- Made commits to the local branch
+- Deleted or renamed files
+- Ran a destructive shell command
+- Called an external API or service
+
+For non-destructive subtasks (read-only analysis, adding new files, editing without committing), proceed to the next subtask without a checkpoint.
+
+Report format after each subtask:
+```
+Subtask N complete: <one-sentence result>. Proceed to subtask N+1?
+```
+
+## Failure inside a subtask
+
+If a subtask cannot be completed:
+1. Try up to 2 approaches within the same subtask (log each attempt)
+2. If still blocked: `TaskUpdate(status="blocked")`, surface the specific obstacle to the user
+3. Never silently skip a blocked subtask — always surface it
+
+## References
+
+- `.claude/commands/claws-goal.md` — the slash command that invokes this skill
+- `.claude/commands/claws-plan.md` — use for pre-work context engineering on complex features
+- `.claude/skills/claws-prompt-templates/SKILL.md` — if the subtask spawns a worker, use these templates

package/.claude/skills/claws-prompt-templates/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: claws-prompt-templates
+description: Production-grade prompt templates for crafting Claws worker missions. Patterns for mission text, completion markers, and hard gates.
+type: skill
+---
+
+# Claws Prompt Templates
+
+Patterns for crafting mission text sent to Claws workers. The boot mechanics are handled by `claws_worker` / `claws_fleet` — these templates are about what you put in the `mission` field.
+
+## NEVER write the literal completion marker inside mission text
+
+**Hard rule:** the literal all-caps `__CLAWS` + `_DONE__` string must not appear anywhere inside the `mission` field you pass to `claws_worker` / `claws_fleet` / `claws_dispatch_subworker`. The pty marker scanner can fire on those bytes during the bracketed-paste of the mission itself, closing the worker terminal before Claude has read the mission. Wave L (`_sendAndSubmitMission` post-paste `markerScanFrom` snapshot) makes this much less likely, but the protocol-level rule remains universal.
+
+**Safe placements** (these run AFTER the mission is delivered, so the scanner is past the paste window):
+- F4 shell command: `printf '%s\n' '__CLAWS_DONE__'` — Bash command, not pasted text.
+- F5 chat-narration final line — emitted by Claude after the worker has fully processed the mission.
+
+**Inside the mission body, always paraphrase**: "the standard Claws completion sentinel", "the all-caps completion marker", "the `__CLAWS` prefix + `_DONE__` suffix", "the canonical worker-done marker". Templates below use those paraphrases.
+
+## Core rules for every mission
+
+1. **End with a paraphrased completion-marker instruction**: `print the standard Claws completion sentinel when done. go.`
+2. **Include F1–F5 final actions** for missions that commit code:
+   - F1: `git status --short` — verify clean working tree
+   - F2: `git log --oneline -5` — verify commits landed
+   - F3 (PRIMARY): `claws_done()` — zero-arg MCP completion (publishes system.worker.completed and closes terminal)
+   - F4 (BACKUP): `printf '%s\n' '__CLAWS_DONE__'` — shell command (executes after mission, so the marker bytes appear post-paste; safe)
+   - F5 (BACKUP): end final assistant message with the all-caps completion marker on its own line
+3. **Set hard gates**: "all tests must pass before commit", "zero tsc errors", "no --no-verify"
+4. **Scope constraints explicitly**: list what files are off-limits
+
+---
+
+## Template 1 — Single Mission Worker
+
+```
+new mission. one task, one deliverable, exit when done.
+
+context: [2-3 sentences the worker needs]
+
+your job: [clear, specific objective in one sentence]
+
+steps:
+1. [first concrete action]
+2. [second concrete action]
+3. [verification — npm test or equivalent; must be green]
+4. [commit with conventional commit message — no --no-verify]
+
+final actions:
+F1: git status --short
+F2: git log --oneline -5
+F3: claws_done()
+F4: printf '%s\n' '__CLAWS_DONE__'   ← shell command; safe (post-paste)
+F5: end final message with the all-caps completion marker on its own line
+
+constraints:
+- do not edit files outside [scope]
+- do not push
+- all tests must pass before committing
+- zero tsc errors after any .ts edit
+
+print the standard Claws completion sentinel when done. go.
+```
+
+---
+
+## Template 2 — Analysis / Audit (read-only)
+
+```
+analysis mission. read-only except for the output file.
+
+context: [what prompted this, what prior work exists]
+
+your job: [specific question to answer]
+
+method:
+1. [primary data source]
+2. [secondary source or comparison]
+3. [specific computation or comparison]
+
+output: write findings to [output-path] with sections:
+(a) [metrics table]
+(b) [ranked recommendations]
+(c) [evidence trail]
+
+constraints:
+- do not edit any file outside [output-path]
+- do not commit
+- numbers first, prose light
+
+F1: git status --short
+F2: git log --oneline -3
+F3: claws_done()
+F4: printf '%s\n' '__CLAWS_DONE__'   ← shell command; safe (post-paste)
+F5: end final message with the all-caps completion marker on its own line
+
+print the standard Claws completion sentinel when done. go.
+```
+
+---
+
+## Template 3 — Multi-Commit Implementation
+
+```
+implementation mission. ship [N] commits in sequence.
+
+context: [reference to the plan that produced these changes]
+
+commit plan:
+1. [description] — edit [files] — message: "[exact message]"
+2. [description] — edit [files] — message: "[exact message]"
+
+for each commit:
+1. make the edits
+2. npx tsc --noEmit — zero errors required
+3. npm test — zero failures required
+4. git add [specific files] && git commit -m "[message]"
+
+if a commit fails verification after 3 retries, write [slug]-FAILED.status and stop.
+
+F1: git status --short
+F2: git log --oneline -5
+F3: claws_done()
+F4: printf '%s\n' '__CLAWS_DONE__'   ← shell command; safe (post-paste)
+F5: end final message with the all-caps completion marker on its own line
+
+constraints:
+- do not push
+- no --no-verify
+
+print the standard Claws completion sentinel when done. go.
+```
+
+---
+
+## Template 4 — Parallel Fleet Worker
+
+```
+worker [A/B/C] of [N]. do not coordinate with other workers.
+
+your scope: [specific subset of the work]
+
+shared context: [background all workers share]
+
+your specific mission: [what THIS worker does]
+
+output: write to [worker-specific-output-path]
+
+constraints:
+- edit ONLY files in your scope
+- if you need to touch a shared file, write to a temp path and flag it for manual merge
+- do not commit unless instructed
+
+F1: git status --short
+F2: git log --oneline -3
+F3: claws_done()
+F4: printf '%s\n' '__CLAWS_DONE__'   ← shell command; safe (post-paste)
+F5: end final message with the all-caps completion marker on its own line
+
+print the standard Claws completion sentinel when done. go.
+```
+
+---
+
+## Anti-patterns
+
+**Vague objective** — worker wastes tokens exploring:
+```
+# BAD
+look at the codebase and suggest improvements
+
+# GOOD
+read extension/src/server.ts lines 120-180. identify which event handlers lack error boundaries. write findings to /tmp/audit.md as a table: handler × line × missing-guard.
+```
+
+**Missing constraints** — worker may commit, push, or run expensive ops:
+```
+# BAD
+fix the bug in auth.ts
+
+# GOOD
+fix the KeyError at auth.ts:87. do not commit. do not push. edit only auth.ts.
+```
+
+**Missing completion marker** — watcher cannot detect completion:
+```
+# BAD
+do the thing and tell me when done
+
+# GOOD
+...print the standard Claws completion sentinel when done. go.
+```
+
+**Literal marker in mission body** — pty scanner fires mid-paste, terminal closes before Claude reads the mission:
+```
+# BAD
+do the thing then print __CLAWS_DONE__ to exit. go.
+
+# GOOD
+do the thing then print the standard Claws completion sentinel to exit. go.
+```
+Reason: the bracketed-paste of the mission echoes those bytes through the pty, and the marker scanner can match before `markerScanFrom` is updated post-paste. The literal marker is safe in F4 (shell command) and F5 (chat narration after mission processing) — never in the mission body itself.