SDK process: ctx.task(myTask)
  ↓ creates effect (journaled)
  ↓
tasks-adapter routes by responder type:
  ├─ type: "internal"  → agent-core session (direct API call)
  ├─ type: "human"     → breakpoint → human responder (existing)
  ├─ type: "agent"     → adapters adapter (claude-code, codex, etc.)
  ├─ type: "tracker"   → external issue tracker (Jira, Linear, GitHub Issues)
  └─ type: "auto"      → tasks-adapter picks best available responder

// packages/tasks-adapter/src/types.ts

type ResponderType = "human" | "agent" | "tracker" | "internal";

interface Responder {
  id: string;
  type: ResponderType;
  name: string;
  capabilities: string[];
  // Agent-specific:
  adapter?: string;        // adapters adapter name
  model?: string;          // default model
  provider?: string;       // default provider
  // Tracker-specific:
  trackerBackend?: string; // "github-issues" | "jira" | "linear"
  trackerConfig?: Record<string, unknown>;
}

// packages/tasks-adapter/src/backends/adapters.ts

class AgentMuxResponderBackend implements BreakpointBackend {
  async submitBreakpoint(params: SubmitBreakpointParams): Promise<Breakpoint> {
    // Route to adapters adapter
    const adapterClient = await getAmuxClient();
    const handle = await adapterClient.run({
      agent: params.routing.targetAdapter,
      prompt: params.question,
      model: params.routing.model,
      nonInteractive: true,
      timeout: params.routing.timeout ?? 300_000,
    });
    
    // Collect result
    const result = await handle.result;
    
    // Return as answered breakpoint
    return {
      ...breakpoint,
      status: "answered",
      answer: { text: result.output, responderId: params.routing.targetAdapter },
    };
  }
  
  // waitForAnswer is immediate — agent responds synchronously
  async waitForAnswer(id: string): Promise<BreakpointAnswer> {
    return this.answers.get(id)!;
  }
}

// Process definition — routes through tasks-adapter
const reviewTask = defineTask("review", (args) => ({
  kind: "agent",
  title: "Code review",
  agent: {
    prompt: "Review the changes...",
    // Routing handled by tasks-adapter, not SDK:
    responderType: "agent",     // tasks-adapter routes to adapters
    adapter: "claude-code",     // hint for tasks-adapter routing
    fallbackType: "internal",   // if adapters unavailable, use internal
  },
}));

// Human review task — same routing system
const approvalTask = defineTask("approval", (args) => ({
  kind: "breakpoint",
  title: "Approve deployment",
  breakpoint: {
    question: "Approve deployment to production?",
    responderType: "human",     // tasks-adapter routes to human
    // Or sync to external tracker:
    responderType: "tracker",
    trackerBackend: "jira",
  },
}));

// Auto-routing — tasks-adapter picks best responder
const flexibleTask = defineTask("flexible", (args) => ({
  kind: "agent",
  title: "Implement feature",
  agent: {
    prompt: "Implement the feature...",
    responderType: "auto",      // tasks-adapter picks based on availability + capabilities
  },
}));

// packages/tasks-adapter/src/router.ts

async function routeTask(task: TaskDef, context: RoutingContext): Promise<Responder> {
  const type = task.agent?.responderType ?? task.breakpoint?.responderType ?? "internal";
  
  switch (type) {
    case "internal":
      return { id: "agent-core", type: "internal", name: "Internal Agent", capabilities: ["text"] };
      
    case "human":
      return await matchHumanResponder(task, context);
      
    case "agent":
      return await matchAgentResponder(task, context);
      
    case "tracker":
      return await matchTrackerResponder(task, context);
      
    case "auto":
      // Try agent first (faster), fall back to human if no agent available
      const agent = await matchAgentResponder(task, context).catch(() => null);
      if (agent) return agent;
      return await matchHumanResponder(task, context);
      
    default:
      throw new Error(`Unknown responder type: ${type}`);
  }
}

async function matchAgentResponder(task: TaskDef, context: RoutingContext): Promise<Responder> {
  const discovery = await discoverExternalAgents();
  if (!discovery.available) {
    if (task.agent?.fallbackType === "internal") {
      return { id: "agent-core", type: "internal", name: "Internal (fallback)", capabilities: ["text"] };
    }
    throw new Error("No agent responders available (adapters not installed)");
  }
  
  const preferred = task.agent?.adapter;
  if (preferred) {
    const agent = discovery.agents.find(a => a.name === preferred && a.installed);
    if (agent) return { id: agent.name, type: "agent", name: agent.displayName, adapter: agent.name, capabilities: agent.capabilities };
    // Preferred not available — try any installed agent
  }
  
  const installed = discovery.agents.filter(a => a.installed && a.authenticated);
  if (installed.length === 0) throw new Error("No authenticated agent responders available");
  return { id: installed[0].name, type: "agent", name: installed[0].displayName, adapter: installed[0].name, capabilities: installed[0].capabilities };
}

Current:
  SDK effect → agent-platform resolveEffect → adapterBridge (direct)

New:
  SDK effect → tasks-adapter.submitTask(effect) → tasks-adapter.routeTask()
    → type=agent  → AgentMuxResponderBackend → adapterBridge
    → type=human  → BreakpointBackend (existing)
    → type=tracker → ExternalTrackerBackend (new)
    → type=internal → agent-core session (existing)