From multi-agent chaos to coordinated collaboration.

Agent A: "I'll add JWT auth to routes.ts"
Agent B: "I'll restructure routes.ts for better organization"
Agent C: "I'll fix the login function in auth.ts"

[30 seconds later]

Agent A commits: routes.ts with new auth middleware
Agent B commits: routes.ts completely restructured (overwrites A)
Agent C commits: auth.ts with bug fix (conflicts with A's changes)

Final state: Broken. Agent A's auth is gone.
Agent C's fix doesn't match the new auth system.

Agent A: scrum_intent_post(files: ["auth.ts", "routes.ts"])
Agent A: scrum_claim(files: ["auth.ts", "routes.ts"])

Agent B: scrum_overlap_check(files: ["routes.ts"])
         → "routes.ts claimed by Agent A"
Agent B: "I'll wait or work on something else"

Agent A finishes → evidence → release
Agent B can now proceed

Agent A says: "I'll modify auth.ts and routes.ts"
Agent A actually modifies: auth.ts, routes.ts, AND config.ts, database.ts

v0.3 response: "OK! Here's your release."

But wait...
- config.ts wasn't declared (scope creep)
- database.ts might be critical for another agent
- Nobody knows until a bug appears days later

{
  score: 100,              // 0-100 compliance score
  canComplete: true,       // All requirements met?
  checks: {
    intentPosted: ✓,       // Did they declare intent?
    evidenceAttached: ✓,   // Did they prove it works?
    filesMatch: {
      declared: ["auth.ts", "routes.ts"],
      modified: ["auth.ts", "routes.ts"],
      undeclared: [],      // Modified but not declared
    },
    boundariesRespected: {
      violations: [],      // Files touched that were off-limits
    }
  }
}

Agent A: scrum_compliance_check(taskId, agentId)
{
  score: 50,
  canComplete: false,
  checks: {
    filesMatch: { passed: false, undeclared: ["config.ts"] },
    boundariesRespected: { passed: false, violations: ["config.ts"] }
  },
  nextSteps: [
    "Revert changes to config.ts (boundary violation)",
    "Or update your intent to include config.ts"
  ]
}

Agent A: "Oh! I didn't mean to touch config.ts. Let me revert."
[Agent A reverts config.ts]
Agent A: scrum_compliance_check → score: 100, canComplete: true
Agent A: scrum_claim_release() → Success!

Orchestrator: "3 sub-agents, implement auth system together"

Sub-Agent 1 (Backend): "I'll create the JWT service"
Sub-Agent 2 (Frontend): "I'll build the login form"
Sub-Agent 3 (Tests): "I'll write integration tests"

[All three work in isolation]

Result:
- Backend uses bcrypt, Frontend expects argon2
- Frontend calls /api/login, Backend exposes /auth/signin
- Tests test the wrong API shape

Total integration time: 4 hours of debugging mismatches

Orchestrator: scrum_sprint_create(taskId, goal: "Implement auth")
              → sprintId: "sprint-abc"

Sub-Agent 1 (Backend):
  scrum_sprint_join(sprintId, workingOn: "JWT service", focusArea: "backend")
  scrum_sprint_share(decision: "Using bcrypt for passwords")
  scrum_sprint_share(interface: "POST /auth/signin → { token }")

Sub-Agent 2 (Frontend):
  scrum_sprint_join(sprintId, workingOn: "Login form", focusArea: "frontend")
  scrum_sprint_context(sprintId)
  → decisions: ["Using bcrypt"]
  → interfaces: ["POST /auth/signin specification"]

  "Perfect! I'll call /auth/signin with the exact shape specified."

  scrum_sprint_share(question: "Where to store refresh tokens?")

Sub-Agent 1 (Backend):
  scrum_sprint_check(sprintId)
  → unansweredQuestions: ["Where to store refresh tokens?"]

  scrum_sprint_share(answer: "Use httpOnly cookies for XSS protection")

Sub-Agent 3 (Tests):
  scrum_sprint_context(sprintId)
  → All decisions, interfaces, and Q&A available

  "I have everything I need to write accurate tests!"