Agent Config Adapter

---
name: Sandbox Dev
description: End-to-end autonomous development in current session. Requires official Claude Code sandbox enabled. Use when user says "sandbox dev", "dev this", "implement this", or provides a task/issue to work on. No containers, no tmux - everything runs here.
allowed-tools: Bash, Write, Read, Edit, MultiEdit, Grep, Glob, Task, WebSearch, WebFetch, Skill, TodoWrite, mcp__jina__*, mcp__github__*, Bash(gh:*), Bash(npm:*), Bash(npx:*), Bash(git:*), Bash(bun:*), Bash(pnpm:*)
---

# Sandbox Dev - In-Session Autonomous Development

**Prerequisite:** Official Claude Code sandbox must be enabled (`/sandbox`).

With sandbox active, you have OS-level isolation + auto-allow mode. No need for
Docker containers or tmux sessions. Everything runs end-to-end in this session.

**Flow:** Plan → Digest & Checkpoint → Implement → Complete

## Trigger Phrases

- "sandbox dev [task]", "dev this", "implement this"
- "work on [feature/bug]", "fix [issue]"
- GitHub refs: `#123`, `GH-123`, ticket URLs

---

## PHASE 0: PREFLIGHT

### Check Sandbox Status

Before starting, verify sandbox is active:

```
If sandbox is NOT enabled:
  → Tell user: "This skill requires sandbox mode. Run `/sandbox` first."
  → STOP
```

### Check for Existing Plan

If `taskNotes/{task-name}/taskFindings.md` already exists for this task: → Skip
to PHASE 3 (Implementation)

Otherwise proceed to PHASE 1.

---

## PHASE 1: PLANNING

Invoke the codePlanner command to create the implementation plan:

```
/codePlanner {github-ticket-id | task-description}
```

This creates `taskNotes/{task-name}/taskFindings.md` with:

- Requirements analysis
- Complexity score
- Implementation plan
- Files to touch

**CRITICAL:** Do NOT ask user to review. Do NOT wait for approval. Proceed
immediately to Phase 2.

---

## PHASE 2: PLAN DIGEST & HUMAN CHECKPOINT

Extract key signals from the plan for quick human review.

### Extract Signals

Read the plan at `{taskFindings.md path}` and extract ONLY these signals. No
opinions, no recommendations — just extract facts.

The plan must have `Original Ask` h2 section (user's requirements). The rest is
the implementation plan.

Analyze the plan against Original Ask to extract:

- Any gaps
- Edge cases
- Potential bugs
- Can the plan be simplified while still meeting Original Ask?

Respond in this EXACT format:

---
**📋 Plan Digest: {task-name}**

| Signal | Value |
|--------|-------|
| Complexity | Score and summarized reason |
| Gaps found | {list} OR "None" |
| Edge cases | {list} OR "None" |
| Potential bugs | {list} OR "None" |
| Simplifications possible | {yes/no} + brief explanation |
| External deps added | {list} OR "None" |
| Highest risk | {single riskiest part of the plan} |
| Files touched | {count}: {comma-separated list} |
| New abstractions | {count}: {names} OR "None" |
| Existing code modified | {Yes — what / No — additive only} |

**Rejected alternatives:** {what simpler approaches were considered but skipped, and the stated reason — or "None mentioned"}

**Watch for:** {flag anything unusual: schema migrations, auth changes, new patterns, broad refactors — or "Nothing unusual"}
---

### Present & Wait

Display the extracted digest to user. Then show:

```
Ready? [g]o · [t]weak: {feedback} · [r]eject/show full plan
```

**WAIT for user input. Do not proceed autonomously.**

### Handle Response

| Input                                  | Action                                                         |
| -------------------------------------- | -------------------------------------------------------------- |
| `g`, `go`, `yes`, 👍                   | Proceed to Phase 3 (Implementation)                            |
| `t: {feedback}` or `tweak: {feedback}` | Update taskFindings.md per feedback, re-extract, present again |
| `r`, `reject`, `plan`, `show`          | Display full taskFindings.md, wait for further input           |
| `stop`, `cancel`                       | Abort workflow                                                 |

---

## PHASE 3: IMPLEMENTATION

Invoke the startWork command with autonomous mode:

```
/startWork {taskFindings.md path}, branch: {branch-name}, mode: autonomous
```

This will:

1. Create/checkout the feature branch
2. Implement all changes from the plan
3. Follow existing codebase patterns
4. Track progress with TodoWrite

The `mode: autonomous` flag tells startWork to proceed without confirmations
since sandbox provides the isolation.

---

## PHASE 4: COMPLETION

After implementation is done, invoke completeWork:

```
/completeWork {task-name}, mode: autonomous
```

This will:

1. Run tests and fix any failures
2. Run linting/type checks
3. Update documentation if needed
4. Prepare commit with proper message

---

## PHASE 5: FINALIZE

After completeWork finishes:

### Summarize Changes

List what was done:

- Files created/modified
- Key decisions made
- Test results
- Any caveats or follow-ups

## Anti-Patterns

**DO NOT:**

- Start without verifying sandbox is enabled
- Skip Phase 2 checkpoint (user must approve plan)
- Run `/startWork` or `/completeWork` without `mode: autonomous`
- Commit without user approval in Phase 5
- Attempt parallel work (use parallel-dev-work instead)

**DO:**

- Use the same slash commands as dev-work
- Let sandbox handle isolation
- Wait for user approval at Phase 2 checkpoint
- Run everything in current session
- Clean summarize at the end

---

## Error Handling

| Phase          | Error               | Action                            |
| -------------- | ------------------- | --------------------------------- |
| Preflight      | Sandbox not enabled | Stop, tell user to run `/sandbox` |
| Planning       | GitHub API fail     | Retry, then ask user for details  |
| Planning       | codePlanner fails   | Report error, ask user to retry   |
| Implementation | Build/test fail     | startWork handles retries         |
| Completion     | Tests fail          | completeWork handles fixes        |

---

No companion files

Add companion files to enhance this skill