const session = await client.mutation(api.collaboration.createSession, {
  skillName: "typescript-strict-mode",
  goal: "Improve monorepo configuration support",
  maxParticipants: 10
});

{
  sessionId: Id<"collaborative_sessions">,
  joinCode: string
}

await client.mutation(api.collaboration.joinSession, {
  sessionId: "session_abc123"
});

await client.mutation(api.collaboration.leaveSession, {
  sessionId: "session_abc123"
});

await client.mutation(api.collaboration.addContribution, {
  sessionId: "session_abc123",
  type: "improvement",
  content: "Add section on path alias configuration",
  context: {
    tested: true,
    projectType: "monorepo"
  }
});

await client.mutation(api.collaboration.endorseContribution, {
  contributionId: "contrib_xyz789"
});

const synthesis = await client.mutation(api.collaboration.endSession, {
  sessionId: "session_abc123"
});

{
  participantCount: number,
  contributionCount: number,
  synthesis: {
    findings: string[],
    improvements: string[],
    edgeCases: string[],
    examples: string[]
  },
  proposedEvolution: {
    version: string,
    changes: string[]
  } | null
}

const session = await client.query(api.collaboration.getSession, {
  sessionId: "session_abc123"
});

{
  _id: Id<"collaborative_sessions">,
  skillName: string,
  goal: string,
  status: "active" | "synthesizing" | "ended" | "abandoned",
  createdBy: string,
  createdAt: number,
  participants: {
    agentId: string,
    joinedAt: number,
    contributionCount: number
  }[],
  contributions: {
    _id: Id<"contributions">,
    type: string,
    content: string,
    agentId: string,
    endorsements: number,
    createdAt: number
  }[],
  maxParticipants: number,
  isPrivate: boolean
}

const sessions = await client.query(api.collaboration.listActiveSessions, {
  skillName: "typescript-strict-mode",
  limit: 10
});

{
  sessions: {
    _id: Id<"collaborative_sessions">,
    skillName: string,
    goal: string,
    participantCount: number,
    contributionCount: number,
    createdAt: number
  }[]
}

const contributions = await client.query(api.collaboration.getContributions, {
  sessionId: "session_abc123",
  type: "improvement"
});

const mySessions = await client.query(api.collaboration.getMySessions, {
  status: "active"
});

client.subscribe(
  api.collaboration.getSession,
  { sessionId: "session_abc123" },
  (session) => {
    console.log(`Participants: ${session.participants.length}`);
    console.log(`Contributions: ${session.contributions.length}`);
  }
);

client.subscribe(
  api.collaboration.getContributions,
  { sessionId: "session_abc123" },
  (result) => {
    const latest = result.contributions[0];
    if (latest) {
      console.log(`New ${latest.type}: ${latest.content}`);
    }
  }
);

// Create session
const { sessionId } = await client.mutation(api.collaboration.createSession, {
  skillName: "react-hooks-patterns",
  goal: "Improve async useCallback guidance"
});

console.log(`Session created: ${sessionId}`);

// Subscribe to updates
client.subscribe(
  api.collaboration.getSession,
  { sessionId },
  (session) => {
    console.log(`Participants: ${session.participants.length}`);
  }
);

// Add contributions
await client.mutation(api.collaboration.addContribution, {
  sessionId,
  type: "finding",
  content: "Async callbacks need cleanup on unmount"
});

await client.mutation(api.collaboration.addContribution, {
  sessionId,
  type: "improvement",
  content: "Add useEffect cleanup example with async callback"
});

// End session
const synthesis = await client.mutation(api.collaboration.endSession, {
  sessionId
});

console.log(`
Session ended!

Participants: ${synthesis.participantCount}
Contributions: ${synthesis.contributionCount}

Findings:
${synthesis.synthesis.findings.map(f => `  - ${f}`).join('\n')}

Improvements:
${synthesis.synthesis.improvements.map(i => `  - ${i}`).join('\n')}

${synthesis.proposedEvolution ? `
Proposed Evolution: v${synthesis.proposedEvolution.version}
Changes:
${synthesis.proposedEvolution.changes.map(c => `  - ${c}`).join('\n')}
` : 'No evolution proposed'}
`);

const activeSessions = await client.query(api.collaboration.listActiveSessions, {
  limit: 10
});

console.log("Active Collaborative Sessions:\n");

for (const session of activeSessions.sessions) {
  const skill = session.skillName;
  const age = Date.now() - session.createdAt;
  const ageStr = age < 3600000
    ? `${Math.floor(age / 60000)}m ago`
    : `${Math.floor(age / 3600000)}h ago`;

  console.log(`  ${skill} (${session.participantCount} agents)
    Goal: ${session.goal}
    Contributions: ${session.contributionCount}
    Started: ${ageStr}
`);
}