abildtoft/kramme:siw:issue-implement:team

Parallel SIW Implementation

Implement multiple SIW issues simultaneously using multi-agent execution. Each agent implements one issue with a full context window, following the kramme:siw:issue-implement workflow.

Arguments: "$ARGUMENTS"

Parse $ARGUMENTS for --auto before Step 1.

• If present, set AUTO_MODE=true and remove the flag from the remaining input.
• --auto means: skip the plan confirmation in Step 4 and start the proposed parallel implementation plan immediately.

Prerequisites

This skill requires multi-agent execution.

• Claude Code: Agent Teams must be enabled (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS).
• Codex: run in a Codex runtime with multi_agent enabled.

If multi-agent execution is not available, print:

Multi-agent execution is not enabled. Use /kramme:siw:issue-implement to implement issues one at a time.
Claude Code: add CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 to settings.json.
Codex: use a runtime with `multi_agent` enabled (for example, Conductor Codex runtime).

Then stop.

Workflow

Step 1: Read SIW State

1. Read siw/OPEN_ISSUES_OVERVIEW.md to understand all issues and their statuses
2. Read the main spec file (from siw/ directory) for project context, excluding temporary artifacts such as DISCOVERY_BRIEF.md
3. Read siw/LOG.md for current progress and decisions
4. Capture each issue's Mode from the overview table when present, then confirm it from the issue file frontmatter when reading candidates. Treat missing Mode as HITL — mode missing; requires human triage.

Step 2: Identify Parallelizable Issues

If specific issue IDs provided (e.g., G-001 P1-002):

• Validate each issue exists and is in READY status
• Warn if any have unresolved blockers
• If any requested issue is HITL, keep it out of the automatic batch until the user explicitly confirms that the required human decision/review/access has already been handled. --auto does not count as that confirmation.

If "phase N" provided (e.g., phase 1):

• Select all READY issues with prefix matching that phase (P1-* for phase 1)
• Exclude HITL issues from the proposed automatic batch and list them separately as human-gated work.

If no arguments:

• Select all READY AUTO issues across all phases that have no unresolved blockers
• Exclude HITL issues from the proposed automatic batch and list them separately as human-gated work.

HITL guardrail:

• Do not spawn implementation agents for HITL issues by default.
• If all candidate issues are HITL, stop and ask the user to resolve the human requirement first or run /kramme:siw:issue-implement for a single issue with the needed context.
• If AUTO_MODE=true, skip HITL issues automatically and report them as not started; if skipping leaves no AUTO candidates, stop without spawning agents.
• If interactive mode includes HITL candidates, Step 4 must present them separately with their one-line reasons and require explicit user confirmation before any HITL issue enters a batch.

Step 3: Analyze File Ownership

For each candidate issue:

1. Read the issue file from siw/issues/
2. Extract "Affected Areas", "Files to Modify", or "Scope" sections
3. Build a file-to-issue map

Identify conflicts:

• Issues that touch overlapping files cannot run in parallel
• Group non-overlapping issues into parallelizable batches

Batching strategy:

• Batch 1: Maximum set of issues with no file overlaps
• Batch 2: Issues that were blocked by Batch 1 file conflicts, OR issues whose SIW blockers are resolved by Batch 1 completions
• Continue until all issues are batched

Step 4: Present Plan

If AUTO_MODE=true, skip this AskUserQuestion and proceed with Start parallel implementation.

Otherwise use AskUserQuestion:

header: "Parallel Implementation Plan"
question: "Ready to implement X issues. Here's the plan:"
options:
  - label: "Start parallel implementation"
    description: |
      Batch 1 (parallel): [issue-ids] - X teammates
      Batch 2 (after batch 1): [issue-ids] - Y teammates
      Human-gated HITL issues not started: [issue-ids with reasons]
      Potential conflicts: [details if any]
  - label: "Adjust plan"
    description: "Let me modify which issues to include"
  - label: "Cancel"
    description: "Don't implement anything"

Step 5: Spawn Implementation Agents

Create a multi-agent implementation session named siw-implement.

• Claude Code: create an Agent Team.
• Codex: launch equivalent parallel implementation agents via multi-agent mode.

For each issue in Batch 1, spawn a teammate with:

Precondition: Every issue in the batch is AUTO, or the user explicitly confirmed inclusion of that specific HITL issue after seeing its reason in Step 4.

1. Issue content: Full text of the issue file
2. Spec context: Relevant sections of the main spec and any supporting specs
3. File ownership: "You have exclusive write access to: [files]. Do NOT modify files outside this list without messaging the lead first."
4. Workflow: "Follow the kramme:siw:issue-implement workflow using the Autonomous Implementation approach:
   • Explore codebase for patterns
   • Create technical plan
   • Implement iteratively
   • Run kramme:verify:run
   • Document resolution in the issue file's ## Resolution section (summary, changes, key decisions)
   • Set issue status to IN REVIEW or DONE based on confidence
   • Update ALL THREE tracking files atomically: issue file status, siw/OPEN_ISSUES_OVERVIEW.md row, and siw/LOG.md current progress
   • Message the lead when complete"
5. Plan approval: Require plan approval before implementation begins. The lead reviews each teammate's technical plan and approves or rejects with feedback.

Create one task per issue: "Implement [issue-id]: [title]"

Step 6: Monitor Progress

While teammates work:

1. Review plans: When a teammate submits their implementation plan, review it for:

   • Alignment with spec and issue requirements
   • No file conflicts with other teammates' plans
   • Appropriate patterns and conventions
   • Approve or reject with specific feedback

2. Track completion: Monitor TaskList for completed tasks

3. Handle file conflicts: If a teammate discovers it needs a file outside its ownership:

   • Check if the owning teammate is done with that file
   • If yes: grant access
   • If no: queue the request, or suggest the teammate implement a different approach that stays within its files

4. Handle blockers: If a teammate gets stuck:

   • Provide additional context about the codebase
   • Suggest alternative approaches
   • In worst case, reassign the issue to a different teammate

Step 7: Proceed to Next Batch

When all Batch 1 tasks complete:

1. Update siw/LOG.md with Batch 1 completions
2. Check if Batch 2 issues are now unblocked (both SIW dependency and file ownership)
3. Assign Batch 2 issues to idle teammates or spawn new ones
4. Repeat monitoring until all batches complete

Step 8: Final Verification

After all issues are implemented:

1. Run kramme:verify:run on the full scope to check for integration issues
2. If verification fails:
   • Identify which teammate's changes caused the failure
   • Either resume that teammate to fix, or fix directly
3. Update siw/LOG.md with session summary:

## Current Progress

**Last Updated:** {date}
**Quick Summary:** Parallel implementation of X issues

### Project Status
- **Status:** In Progress | **Completed this session:** {issue-ids}

### Last Completed
- {issue-id}: {title} (Batch 1)
- {issue-id}: {title} (Batch 1)
- {issue-id}: {title} (Batch 2)

### Decisions Made
- [Any cross-cutting decisions discovered during parallel implementation]

### Next Steps
1. {next ready issue or phase}

4. Check for phase completion (same as kramme:siw:issue-implement Step 11.2)

Step 9: Spec Sync

Review all decisions logged by teammates. If any need spec updates, follow kramme:siw:issue-implement Step 10 (Sync Decisions to Spec).

Step 10: Cleanup

1. Shut down all implementation agents
2. Clean up the multi-agent session

File Conflict Prevention

This skill uses a multi-layer approach:

1. Pre-analysis: Before spawning, the lead reads each issue's affected areas and builds a file ownership map
2. Exclusive ownership: Each agent gets an explicit list of files it can write to
3. Batching: Issues with file overlaps go into sequential batches
4. Plan approval: Lead reviews each teammate's plan to catch file conflicts early
5. Runtime messaging: Agents message the lead if they discover they need files outside their set
6. Post-verification: kramme:verify:run catches any integration issues after all implementations

Usage

/kramme:siw:issue-implement:team
# Implement all READY issues with no blockers

/kramme:siw:issue-implement:team phase 1
# Implement all READY Phase 1 issues

/kramme:siw:issue-implement:team P1-001 P1-003 G-002
# Implement specific issues in parallel

When to Use This vs /kramme:siw:issue-implement

Use this skill when:

• Multiple READY issues exist with no blocking dependencies
• Issues touch different files/modules
• You want to speed up a phase by parallelizing independent work

Use /kramme:siw:issue-implement when:

• Implementing a single issue
• Issues are tightly coupled and need sequential implementation
• You want lower token cost