npx claude-flow@alpha sparc run dev "task"    # Uses old implementation
npx claude-flow@alpha hooks pre-task "desc"   # Doesn't use checkpoints
npx claude-flow@alpha swarm init mesh         # Doesn't use session forking

mcp__claude-flow__swarm_init           // Doesn't create real forks
mcp__claude-flow__task_orchestrate     // Doesn't use pause/resume
mcp__claude-flow__agent_spawn          // Doesn't checkpoint

export async function swarm_init({ topology }) {
  // Uses Promise.allSettled (not real forking)
  const results = await Promise.allSettled(tasks);
  return { results };
}

import { RealSessionForking } from '../../sdk/session-forking.js';

const forking = new RealSessionForking();

export async function swarm_init({ topology, sessionId }) {
  // Create base session
  const baseQuery = query({ prompt: '...', options: {} });
  await forking.trackSession(sessionId, baseQuery);

  // Fork for each agent in swarm
  const forks = await Promise.all(
    agentIds.map(id => forking.fork(sessionId, {}))
  );

  return {
    swarmId: sessionId,
    agents: forks.map(f => ({ id: f.sessionId, parent: f.parentSessionId }))
  };
}

// src/cli/commands/checkpoint.ts (NEW FILE)
import { checkpointManager } from '../../sdk/checkpoint-manager.js';

export async function checkpointCreate(sessionId: string, description: string) {
  const id = await checkpointManager.createCheckpoint(sessionId, description);
  console.log(`Checkpoint created: ${id}`);
  return id;
}

export async function checkpointList(sessionId: string) {
  const checkpoints = checkpointManager.listCheckpoints(sessionId);
  console.table(checkpoints);
  return checkpoints;
}

export async function checkpointRollback(checkpointId: string, prompt?: string) {
  const query = await checkpointManager.rollbackToCheckpoint(checkpointId, prompt);
  console.log(`Rolled back to checkpoint: ${checkpointId}`);
  return query;
}

npx claude-flow@alpha checkpoint create <session-id> "Before deployment"
npx claude-flow@alpha checkpoint list <session-id>
npx claude-flow@alpha checkpoint rollback <checkpoint-id>

import { checkpointManager } from '../sdk/checkpoint-manager.js';

export async function postTaskHook(event: PostTaskEvent) {
  const { taskId, sessionId, success } = event;

  // Auto-checkpoint after successful tasks
  if (success) {
    await checkpointManager.createCheckpoint(
      sessionId,
      `After task: ${taskId}`
    );
  }
}

export async function preCompactHook(event: PreCompactEvent) {
  const { sessionId } = event;

  // Always checkpoint before compaction (lossy operation)
  await checkpointManager.createCheckpoint(
    sessionId,
    'Before compaction (safety checkpoint)'
  );
}

import {
  createMathMcpServer,
  createSessionMcpServer,
  createCheckpointMcpServer,
  createQueryControlMcpServer,
} from '../sdk/in-process-mcp.js';

export function createClaudeFlowMcpServer() {
  return {
    stdio: createStdioMcpServer(),       // Existing stdio server
    inProcess: {
      math: createMathMcpServer(),           // Fast math operations
      session: createSessionMcpServer(),     // Session state management
      checkpoint: createCheckpointMcpServer(), // Checkpoint management
      queryControl: createQueryControlMcpServer(), // Pause/resume
    }
  };
}

# Install Claude Flow MCP
claude mcp add claude-flow npx claude-flow@alpha mcp start

# Now has access to BOTH:
# - stdio tools (swarm_init, agent_spawn, etc.)
# - in-process tools (checkpoint_create, session_get, etc.)

import { checkpointManager } from '../sdk/checkpoint-manager.js';

export async function runSparcMode(mode: string, task: string) {
  const sessionId = `sparc-${mode}-${Date.now()}`;

  // Create checkpoint at each SPARC phase
  const phases = ['specification', 'pseudocode', 'architecture', 'refinement', 'completion'];

  for (const phase of phases) {
    console.log(`Starting phase: ${phase}`);

    // Checkpoint before phase
    const beforeCheckpoint = await checkpointManager.createCheckpoint(
      sessionId,
      `Before ${phase}`
    );

    // Execute phase
    const result = await executePhase(phase, task);

    // Checkpoint after phase
    const afterCheckpoint = await checkpointManager.createCheckpoint(
      sessionId,
      `After ${phase} (${result.success ? 'success' : 'failed'})`
    );

    // If phase failed, rollback to before-checkpoint
    if (!result.success) {
      console.log(`Phase ${phase} failed, rolling back...`);
      await checkpointManager.rollbackToCheckpoint(beforeCheckpoint);
      break;
    }
  }
}

npx claude-flow@alpha sparc run dev "Build API"
# Now automatically creates checkpoints at each phase
# Can rollback if any phase fails

# Initialize swarm with real session forking
npx claude-flow@alpha swarm init mesh --enable-forking

# Fork swarm to try different approach
npx claude-flow@alpha swarm fork <swarm-id> "Try hierarchical"

# Commit or rollback fork
npx claude-flow@alpha swarm commit <fork-id>
npx claude-flow@alpha swarm rollback <fork-id>

# Run SPARC with auto-checkpointing
npx claude-flow@alpha sparc run dev "Build feature" --enable-checkpoints

# List checkpoints
npx claude-flow@alpha checkpoint list <session-id>

# Rollback to any phase
npx claude-flow@alpha checkpoint rollback <checkpoint-id>

# Start long task
npx claude-flow@alpha task run "Build entire app" --session-id my-task

# Pause if needed (saves state to disk)
npx claude-flow@alpha task pause my-task

# Resume hours/days later
npx claude-flow@alpha task resume my-task

// In Claude Code query
const result = query({
  prompt: `
    Use mcp__claude-flow__swarm_init to create mesh swarm.
    Enable session forking for parallel exploration.
    Create checkpoint before risky operations.

    Then use in-process checkpoint tool to manage state.
  `,
  options: {
    // MCP tools auto-available
  }
});

# Features disabled by default, opt-in with flags
npx claude-flow@alpha swarm init mesh --enable-forking
npx claude-flow@alpha sparc run dev "task" --enable-checkpoints

# Features enabled by default, opt-out with flags
npx claude-flow@alpha swarm init mesh --disable-forking
npx claude-flow@alpha sparc run dev "task" --disable-checkpoints

# Features always enabled, no flags needed
npx claude-flow@alpha swarm init mesh    # Forking enabled
npx claude-flow@alpha sparc run dev "task"  # Checkpoints enabled

{
  "sdk": {
    "sessionForking": {
      "enabled": true,
      "autoCleanup": true
    },
    "checkpoints": {
      "enabled": true,
      "autoInterval": 10,
      "maxPerSession": 50,
      "persistPath": ".claude-flow/checkpoints"
    },
    "queryControl": {
      "enabled": true,
      "autoPauseOnError": true,
      "persistPath": ".claude-flow/paused-queries"
    },
    "inProcessMcp": {
      "enabled": true,
      "servers": ["math", "session", "checkpoint", "queryControl"]
    }
  }
}

CLAUDE_FLOW_ENABLE_FORKING=true
CLAUDE_FLOW_ENABLE_CHECKPOINTS=true
CLAUDE_FLOW_CHECKPOINT_INTERVAL=10
CLAUDE_FLOW_ENABLE_PAUSE_RESUME=true