@dolusoft/claude-collab 0.1.5 → 1.3.0

package/dist/cli.js

@@ -1,1822 +1,773 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import WebSocket2, { WebSocketServer, WebSocket } from 'ws';
+import { WebSocketServer, WebSocket } from 'ws';
+import { createServer } from 'net';
 import { v4 } from 'uuid';
+import multicastDns from 'multicast-dns';
+import { EventEmitter } from 'events';
+import { execFile } from 'child_process';
+import { unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { spawn } from 'child_process';
-import { createConnection } from 'net';
 
-// src/domain/entities/member.entity.ts
-var Member = class _Member {
-  _id;
-  _teamId;
-  _displayName;
-  _connectedAt;
-  _status;
-  _lastActivityAt;
-  constructor(props) {
-    this._id = props.id;
-    this._teamId = props.teamId;
-    this._displayName = props.displayName;
-    this._connectedAt = props.connectedAt;
-    this._status = props.status;
-    this._lastActivityAt = props.connectedAt;
-  }
-  /**
-   * Creates a new Member instance
-   */
-  static create(props) {
-    if (!props.displayName.trim()) {
-      throw new Error("Display name cannot be empty");
-    }
-    return new _Member(props);
-  }
-  /**
-   * Reconstitutes a Member from persistence
-   */
-  static reconstitute(props) {
-    const member = new _Member(props);
-    member._lastActivityAt = props.lastActivityAt;
-    return member;
-  }
-  // Getters
-  get id() {
-    return this._id;
-  }
-  get teamId() {
-    return this._teamId;
-  }
-  get displayName() {
-    return this._displayName;
-  }
-  get connectedAt() {
-    return this._connectedAt;
-  }
-  get status() {
-    return this._status;
-  }
-  get lastActivityAt() {
-    return this._lastActivityAt;
-  }
-  get isOnline() {
-    return this._status === "ONLINE" /* ONLINE */ || this._status === "IDLE" /* IDLE */;
-  }
-  // Behaviors
-  /**
-   * Marks the member as online
-   */
-  goOnline() {
-    this._status = "ONLINE" /* ONLINE */;
-    this._lastActivityAt = /* @__PURE__ */ new Date();
-  }
-  /**
-   * Marks the member as idle
-   */
-  goIdle() {
-    this._status = "IDLE" /* IDLE */;
-  }
-  /**
-   * Marks the member as offline
-   */
-  goOffline() {
-    this._status = "OFFLINE" /* OFFLINE */;
-  }
-  /**
-   * Records activity from this member
-   */
-  recordActivity() {
-    this._lastActivityAt = /* @__PURE__ */ new Date();
-    if (this._status === "IDLE" /* IDLE */) {
-      this._status = "ONLINE" /* ONLINE */;
-    }
-  }
-  /**
-   * Converts entity to plain object for serialization
-   */
-  toJSON() {
-    return {
-      id: this._id,
-      teamId: this._teamId,
-      displayName: this._displayName,
-      connectedAt: this._connectedAt,
-      status: this._status,
-      lastActivityAt: this._lastActivityAt
-    };
-  }
-};
-var BaseDomainEvent = class {
-  eventId;
-  timestamp;
+var SERVICE_TYPE = "_claude-collab._tcp.local";
+var MdnsDiscovery = class {
+  mdns;
+  announced = false;
+  port = 0;
+  teamName = "";
+  memberId = "";
+  peersByTeam = /* @__PURE__ */ new Map();
+  peersByMemberId = /* @__PURE__ */ new Map();
+  onPeerFoundCb;
+  onPeerLostCb;
   constructor() {
-    this.eventId = v4();
-    this.timestamp = /* @__PURE__ */ new Date();
-  }
-  /**
-   * Converts event to JSON
-   */
-  toJSON() {
-    return {
-      eventId: this.eventId,
-      eventType: this.eventType,
-      timestamp: this.timestamp,
-      payload: this.payload
-    };
-  }
-};
-
-// src/domain/events/member-joined.event.ts
-var MemberJoinedEvent = class _MemberJoinedEvent extends BaseDomainEvent {
-  constructor(memberId, teamId, displayName) {
-    super();
-    this.memberId = memberId;
-    this.teamId = teamId;
-    this.displayName = displayName;
-  }
-  static EVENT_TYPE = "MEMBER_JOINED";
-  get eventType() {
-    return _MemberJoinedEvent.EVENT_TYPE;
-  }
-  get payload() {
-    return {
-      memberId: this.memberId,
-      teamId: this.teamId,
-      displayName: this.displayName
-    };
-  }
-};
-
-// src/shared/types/branded-types.ts
-var MemberId = {
-  create: (id) => id,
-  isValid: (id) => id.length > 0
-};
-var TeamId = {
-  create: (id) => id.toLowerCase().trim(),
-  isValid: (id) => /^[a-z][a-z0-9-]*$/.test(id.toLowerCase().trim())
-};
-var QuestionId = {
-  create: (id) => id,
-  isValid: (id) => id.length > 0
-};
-var AnswerId = {
-  create: (id) => id,
-  isValid: (id) => id.length > 0
-};
-
-// src/shared/utils/id-generator.ts
-function generateMemberId() {
-  return MemberId.create(v4());
-}
-function createTeamId(name) {
-  return TeamId.create(name);
-}
-function generateQuestionId() {
-  return QuestionId.create(`q_${v4()}`);
-}
-function generateAnswerId() {
-  return AnswerId.create(`a_${v4()}`);
-}
-
-// src/shared/errors/domain-errors.ts
-var DomainError = class extends Error {
-  code;
-  timestamp;
-  constructor(message, code) {
-    super(message);
-    this.name = this.constructor.name;
-    this.code = code;
-    this.timestamp = /* @__PURE__ */ new Date();
-    Error.captureStackTrace(this, this.constructor);
-  }
-};
-var TeamNotFoundError = class extends DomainError {
-  constructor(teamId) {
-    super(`Team '${teamId}' not found`, "TEAM_NOT_FOUND");
+    this.mdns = multicastDns();
+    this.setupHandlers();
   }
-};
-var MemberNotFoundError = class extends DomainError {
-  constructor(memberId) {
-    super(`Member '${memberId}' not found`, "MEMBER_NOT_FOUND");
-  }
-};
-var QuestionNotFoundError = class extends DomainError {
-  constructor(questionId) {
-    super(`Question '${questionId}' not found`, "QUESTION_NOT_FOUND");
-  }
-};
-var QuestionAlreadyAnsweredError = class extends DomainError {
-  constructor(questionId) {
-    super(`Question '${questionId}' has already been answered`, "QUESTION_ALREADY_ANSWERED");
-  }
-};
-var ValidationError = class extends DomainError {
-  field;
-  constructor(field, message) {
-    super(message, "VALIDATION_ERROR");
-    this.field = field;
-  }
-};
-
-// src/application/use-cases/join-team.use-case.ts
-var JoinTeamUseCase = class {
-  constructor(deps) {
-    this.deps = deps;
+  get serviceName() {
+    return `${this.memberId}.${SERVICE_TYPE}`;
   }
-  /**
-   * Executes the use case
-   */
-  async execute(input) {
-    if (!input.teamName.trim()) {
-      throw new ValidationError("teamName", "Team name cannot be empty");
-    }
-    if (!input.displayName.trim()) {
-      throw new ValidationError("displayName", "Display name cannot be empty");
-    }
-    const team = await this.deps.teamRepository.getOrCreate(input.teamName);
-    const memberId = generateMemberId();
-    const member = Member.create({
-      id: memberId,
-      teamId: team.id,
-      displayName: input.displayName.trim(),
-      connectedAt: /* @__PURE__ */ new Date(),
-      status: "ONLINE" /* ONLINE */
+  buildAnswers() {
+    return [
+      {
+        name: SERVICE_TYPE,
+        type: "PTR",
+        ttl: 300,
+        data: this.serviceName
+      },
+      {
+        name: this.serviceName,
+        type: "SRV",
+        ttl: 300,
+        data: {
+          priority: 0,
+          weight: 0,
+          port: this.port,
+          target: "localhost"
+        }
+      },
+      {
+        name: this.serviceName,
+        type: "TXT",
+        ttl: 300,
+        data: [
+          Buffer.from(`team=${this.teamName}`),
+          Buffer.from(`memberId=${this.memberId}`),
+          Buffer.from("ver=1")
+        ]
+      }
+    ];
+  }
+  setupHandlers() {
+    this.mdns.on("query", (query) => {
+      if (!this.announced) return;
+      const questions = query.questions ?? [];
+      const ptrQuery = questions.find(
+        (q) => q.type === "PTR" && q.name === SERVICE_TYPE
+      );
+      if (!ptrQuery) return;
+      this.mdns.respond({ answers: this.buildAnswers() });
     });
-    await this.deps.memberRepository.save(member);
-    team.addMember(memberId);
-    await this.deps.teamRepository.save(team);
-    if (this.deps.onMemberJoined) {
-      const event = new MemberJoinedEvent(memberId, team.id, member.displayName);
-      await this.deps.onMemberJoined(event);
-    }
-    return {
-      memberId,
-      teamId: team.id,
-      teamName: team.name,
-      displayName: member.displayName,
-      status: member.status,
-      memberCount: team.memberCount
-    };
-  }
-};
-
-// src/domain/entities/question.entity.ts
-var Question = class _Question {
-  _id;
-  _fromMemberId;
-  _toTeamId;
-  _content;
-  _createdAt;
-  _status;
-  _answeredAt;
-  _answeredByMemberId;
-  constructor(props) {
-    this._id = props.id;
-    this._fromMemberId = props.fromMemberId;
-    this._toTeamId = props.toTeamId;
-    this._content = props.content;
-    this._createdAt = props.createdAt;
-    this._status = props.status;
-    this._answeredAt = props.answeredAt;
-    this._answeredByMemberId = props.answeredByMemberId;
-  }
-  /**
-   * Creates a new Question instance
-   */
-  static create(props) {
-    return new _Question({
-      ...props,
-      status: "PENDING" /* PENDING */
+    this.mdns.on("response", (response) => {
+      this.parseResponse(response);
     });
   }
-  /**
-   * Reconstitutes a Question from persistence
-   */
-  static reconstitute(props) {
-    return new _Question(props);
-  }
-  // Getters
-  get id() {
-    return this._id;
-  }
-  get fromMemberId() {
-    return this._fromMemberId;
-  }
-  get toTeamId() {
-    return this._toTeamId;
-  }
-  get content() {
-    return this._content;
-  }
-  get createdAt() {
-    return this._createdAt;
-  }
-  get status() {
-    return this._status;
-  }
-  get answeredAt() {
-    return this._answeredAt;
-  }
-  get answeredByMemberId() {
-    return this._answeredByMemberId;
-  }
-  get isPending() {
-    return this._status === "PENDING" /* PENDING */;
-  }
-  get isAnswered() {
-    return this._status === "ANSWERED" /* ANSWERED */;
-  }
-  get isTimedOut() {
-    return this._status === "TIMEOUT" /* TIMEOUT */;
-  }
-  get isCancelled() {
-    return this._status === "CANCELLED" /* CANCELLED */;
-  }
-  get canBeAnswered() {
-    return this._status === "PENDING" /* PENDING */;
-  }
-  /**
-   * Calculates the age of the question in milliseconds
-   */
-  get ageMs() {
-    return Date.now() - this._createdAt.getTime();
-  }
-  // Behaviors
-  /**
-   * Marks the question as answered
-   * @throws QuestionAlreadyAnsweredError if already answered
-   */
-  markAsAnswered(answeredByMemberId) {
-    if (!this.canBeAnswered) {
-      throw new QuestionAlreadyAnsweredError(this._id);
-    }
-    this._status = "ANSWERED" /* ANSWERED */;
-    this._answeredAt = /* @__PURE__ */ new Date();
-    this._answeredByMemberId = answeredByMemberId;
-  }
-  /**
-   * Marks the question as timed out
-   */
-  markAsTimedOut() {
-    if (this._status === "PENDING" /* PENDING */) {
-      this._status = "TIMEOUT" /* TIMEOUT */;
-    }
-  }
-  /**
-   * Marks the question as cancelled
-   */
-  markAsCancelled() {
-    if (this._status === "PENDING" /* PENDING */) {
-      this._status = "CANCELLED" /* CANCELLED */;
-    }
-  }
-  /**
-   * Converts entity to plain object for serialization
-   */
-  toJSON() {
-    return {
-      id: this._id,
-      fromMemberId: this._fromMemberId,
-      toTeamId: this._toTeamId,
-      content: this._content,
-      createdAt: this._createdAt,
-      status: this._status,
-      answeredAt: this._answeredAt,
-      answeredByMemberId: this._answeredByMemberId
-    };
-  }
-};
-
-// src/config/index.ts
-var config = {
-  /**
-   * WebSocket Hub configuration
-   */
-  hub: {
-    /**
-     * Default port for the Hub server
-     */
-    port: parseInt(process.env["CLAUDE_COLLAB_PORT"] ?? "9999", 10),
-    /**
-     * Host to bind the Hub server to
-     */
-    host: process.env["CLAUDE_COLLAB_HOST"] ?? "localhost",
-    /**
-     * Heartbeat interval in milliseconds
-     */
-    heartbeatInterval: 3e4,
-    /**
-     * Client timeout in milliseconds (no heartbeat received)
-     */
-    clientTimeout: 6e4
-  },
-  /**
-   * Communication configuration
-   */
-  communication: {
-    /**
-     * Default timeout for waiting for an answer (in milliseconds)
-     */
-    defaultTimeout: 3e4,
-    /**
-     * Maximum message content length
-     */
-    maxMessageLength: 5e4
-  },
-  /**
-   * Auto-start configuration
-   */
-  autoStart: {
-    /**
-     * Maximum retries when connecting to hub
-     */
-    maxRetries: 3,
-    /**
-     * Delay between retries in milliseconds
-     */
-    retryDelay: 1e3
-  }
-};
-
-// src/domain/value-objects/message-content.vo.ts
-var MessageContent = class _MessageContent {
-  _text;
-  _format;
-  constructor(text, format) {
-    this._text = text;
-    this._format = format;
-  }
-  /**
-   * Creates a new MessageContent
-   * @throws ValidationError if content is invalid
-   */
-  static create(text, format = "markdown") {
-    const trimmedText = text.trim();
-    if (!trimmedText) {
-      throw new ValidationError("text", "Message content cannot be empty");
-    }
-    if (trimmedText.length > config.communication.maxMessageLength) {
-      throw new ValidationError(
-        "text",
-        `Message content exceeds maximum length of ${config.communication.maxMessageLength} characters`
+  parseResponse(response) {
+    const allRecords = [
+      ...response.answers ?? [],
+      ...response.additionals ?? []
+    ];
+    const ptrRecords = allRecords.filter(
+      (r) => r.type === "PTR" && r.name === SERVICE_TYPE
+    );
+    for (const ptr of ptrRecords) {
+      const instanceName = ptr.data;
+      const srv = allRecords.find(
+        (r) => r.type === "SRV" && r.name === instanceName
       );
-    }
-    return new _MessageContent(trimmedText, format);
-  }
-  /**
-   * Creates a plain text message
-   */
-  static plain(text) {
-    return _MessageContent.create(text, "plain");
-  }
-  /**
-   * Creates a markdown message
-   */
-  static markdown(text) {
-    return _MessageContent.create(text, "markdown");
-  }
-  /**
-   * Reconstitutes from persistence
-   */
-  static reconstitute(props) {
-    return new _MessageContent(props.text, props.format);
-  }
-  // Getters
-  get text() {
-    return this._text;
-  }
-  get format() {
-    return this._format;
-  }
-  get length() {
-    return this._text.length;
-  }
-  get isMarkdown() {
-    return this._format === "markdown";
-  }
-  get isPlain() {
-    return this._format === "plain";
-  }
-  /**
-   * Returns a preview of the content (first 100 chars)
-   */
-  get preview() {
-    if (this._text.length <= 100) {
-      return this._text;
-    }
-    return `${this._text.substring(0, 97)}...`;
-  }
-  /**
-   * Checks equality with another MessageContent
-   */
-  equals(other) {
-    return this._text === other._text && this._format === other._format;
-  }
-  /**
-   * Converts to plain object for serialization
-   */
-  toJSON() {
-    return {
-      text: this._text,
-      format: this._format
-    };
-  }
-  /**
-   * String representation
-   */
-  toString() {
-    return this._text;
-  }
-};
-
-// src/domain/events/question-asked.event.ts
-var QuestionAskedEvent = class _QuestionAskedEvent extends BaseDomainEvent {
-  constructor(questionId, fromMemberId, toTeamId, contentPreview) {
-    super();
-    this.questionId = questionId;
-    this.fromMemberId = fromMemberId;
-    this.toTeamId = toTeamId;
-    this.contentPreview = contentPreview;
-  }
-  static EVENT_TYPE = "QUESTION_ASKED";
-  get eventType() {
-    return _QuestionAskedEvent.EVENT_TYPE;
-  }
-  get payload() {
-    return {
-      questionId: this.questionId,
-      fromMemberId: this.fromMemberId,
-      toTeamId: this.toTeamId,
-      contentPreview: this.contentPreview
-    };
-  }
-};
-
-// src/application/use-cases/ask-question.use-case.ts
-var AskQuestionUseCase = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  /**
-   * Executes the use case
-   */
-  async execute(input) {
-    const member = await this.deps.memberRepository.findById(input.fromMemberId);
-    if (!member) {
-      throw new MemberNotFoundError(input.fromMemberId);
-    }
-    const targetTeamId = createTeamId(input.toTeamName);
-    const targetTeam = await this.deps.teamRepository.findById(targetTeamId);
-    if (!targetTeam) {
-      throw new TeamNotFoundError(input.toTeamName);
-    }
-    if (member.teamId === targetTeamId) {
-      throw new ValidationError("toTeamName", "Cannot ask question to your own team");
-    }
-    const content = MessageContent.create(input.content, input.format ?? "markdown");
-    const questionId = generateQuestionId();
-    const question = Question.create({
-      id: questionId,
-      fromMemberId: input.fromMemberId,
-      toTeamId: targetTeamId,
-      content,
-      createdAt: /* @__PURE__ */ new Date()
-    });
-    await this.deps.questionRepository.save(question);
-    member.recordActivity();
-    await this.deps.memberRepository.save(member);
-    if (this.deps.onQuestionAsked) {
-      const event = new QuestionAskedEvent(
-        questionId,
-        input.fromMemberId,
-        targetTeamId,
-        content.preview
+      const txt = allRecords.find(
+        (r) => r.type === "TXT" && r.name === instanceName
       );
-      await this.deps.onQuestionAsked(event);
-    }
-    return {
-      questionId,
-      toTeamId: targetTeamId,
-      status: question.status,
-      createdAt: question.createdAt
-    };
-  }
-};
-
-// src/application/use-cases/get-inbox.use-case.ts
-var GetInboxUseCase = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  /**
-   * Executes the use case
-   */
-  async execute(input) {
-    const member = await this.deps.memberRepository.findById(input.memberId);
-    if (!member) {
-      throw new MemberNotFoundError(input.memberId);
-    }
-    const team = await this.deps.teamRepository.findById(input.teamId);
-    if (!team) {
-      throw new TeamNotFoundError(input.teamId);
-    }
-    const allQuestions = await this.deps.questionRepository.findPendingByTeamId(input.teamId);
-    const questions = input.includeAnswered ? allQuestions : allQuestions.filter((q) => q.isPending);
-    const questionItems = [];
-    for (const question of questions) {
-      const fromMember = await this.deps.memberRepository.findById(question.fromMemberId);
-      const fromTeam = fromMember ? await this.deps.teamRepository.findById(fromMember.teamId) : null;
-      questionItems.push({
-        questionId: question.id,
-        fromMemberId: question.fromMemberId,
-        fromDisplayName: fromMember?.displayName ?? "Unknown",
-        fromTeamName: fromTeam?.name ?? "Unknown",
-        content: question.content.text,
-        format: question.content.format,
-        status: question.status,
-        createdAt: question.createdAt,
-        ageMs: question.ageMs
-      });
+      if (!srv) continue;
+      const port = srv.data.port;
+      const host = "localhost";
+      let teamName = "";
+      let memberId = "";
+      if (txt) {
+        const txtData = txt.data ?? [];
+        for (const entry of txtData) {
+          const str = Buffer.isBuffer(entry) ? entry.toString() : String(entry);
+          if (str.startsWith("team=")) teamName = str.slice(5);
+          if (str.startsWith("memberId=")) memberId = str.slice(9);
+        }
+      }
+      if (!teamName || !memberId) continue;
+      if (memberId === this.memberId) continue;
+      const ptrTtl = ptr.ttl ?? 300;
+      const srvTtl = srv.ttl ?? 300;
+      if (ptrTtl === 0 || srvTtl === 0) {
+        this.peersByTeam.delete(teamName);
+        this.peersByMemberId.delete(memberId);
+        this.onPeerLostCb?.(memberId);
+        continue;
+      }
+      const peer = { host, port, teamName, memberId };
+      this.peersByTeam.set(teamName, peer);
+      this.peersByMemberId.set(memberId, peer);
+      this.onPeerFoundCb?.(peer);
     }
-    questionItems.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-    const pendingCount = questionItems.filter((q) => q.status === "PENDING" /* PENDING */).length;
-    return {
-      teamId: team.id,
-      teamName: team.name,
-      questions: questionItems,
-      totalCount: questionItems.length,
-      pendingCount
-    };
-  }
-};
-
-// src/domain/entities/answer.entity.ts
-var Answer = class _Answer {
-  _id;
-  _questionId;
-  _fromMemberId;
-  _content;
-  _createdAt;
-  constructor(props) {
-    this._id = props.id;
-    this._questionId = props.questionId;
-    this._fromMemberId = props.fromMemberId;
-    this._content = props.content;
-    this._createdAt = props.createdAt;
   }
   /**
-   * Creates a new Answer instance
+   * Announce this node's service via mDNS.
+   * Sends an unsolicited response so existing peers notice immediately.
    */
-  static create(props) {
-    return new _Answer(props);
-  }
-  /**
-   * Reconstitutes an Answer from persistence
-   */
-  static reconstitute(props) {
-    return new _Answer(props);
-  }
-  // Getters
-  get id() {
-    return this._id;
-  }
-  get questionId() {
-    return this._questionId;
-  }
-  get fromMemberId() {
-    return this._fromMemberId;
-  }
-  get content() {
-    return this._content;
-  }
-  get createdAt() {
-    return this._createdAt;
-  }
-  /**
-   * Converts entity to plain object for serialization
-   */
-  toJSON() {
-    return {
-      id: this._id,
-      questionId: this._questionId,
-      fromMemberId: this._fromMemberId,
-      content: this._content,
-      createdAt: this._createdAt
-    };
-  }
-};
-
-// src/domain/events/question-answered.event.ts
-var QuestionAnsweredEvent = class _QuestionAnsweredEvent extends BaseDomainEvent {
-  constructor(questionId, answerId, answeredByMemberId, contentPreview) {
-    super();
-    this.questionId = questionId;
-    this.answerId = answerId;
-    this.answeredByMemberId = answeredByMemberId;
-    this.contentPreview = contentPreview;
-  }
-  static EVENT_TYPE = "QUESTION_ANSWERED";
-  get eventType() {
-    return _QuestionAnsweredEvent.EVENT_TYPE;
-  }
-  get payload() {
-    return {
-      questionId: this.questionId,
-      answerId: this.answerId,
-      answeredByMemberId: this.answeredByMemberId,
-      contentPreview: this.contentPreview
-    };
-  }
-};
-
-// src/application/use-cases/reply-question.use-case.ts
-var ReplyQuestionUseCase = class {
-  constructor(deps) {
-    this.deps = deps;
+  announce(port, teamName, memberId) {
+    this.port = port;
+    this.teamName = teamName;
+    this.memberId = memberId;
+    this.announced = true;
+    this.mdns.respond({ answers: this.buildAnswers() });
   }
   /**
-   * Executes the use case
+   * Send a PTR query to discover existing peers.
    */
-  async execute(input) {
-    const member = await this.deps.memberRepository.findById(input.fromMemberId);
-    if (!member) {
-      throw new MemberNotFoundError(input.fromMemberId);
-    }
-    const question = await this.deps.questionRepository.findById(input.questionId);
-    if (!question) {
-      throw new QuestionNotFoundError(input.questionId);
-    }
-    if (!question.canBeAnswered) {
-      throw new QuestionAlreadyAnsweredError(input.questionId);
-    }
-    const content = MessageContent.create(input.content, input.format ?? "markdown");
-    const answerId = generateAnswerId();
-    const answer = Answer.create({
-      id: answerId,
-      questionId: input.questionId,
-      fromMemberId: input.fromMemberId,
-      content,
-      createdAt: /* @__PURE__ */ new Date()
+  discover() {
+    this.mdns.query({
+      questions: [{ name: SERVICE_TYPE, type: "PTR" }]
     });
-    question.markAsAnswered(input.fromMemberId);
-    await this.deps.answerRepository.save(answer);
-    await this.deps.questionRepository.save(question);
-    member.recordActivity();
-    await this.deps.memberRepository.save(member);
-    if (this.deps.onQuestionAnswered) {
-      const event = new QuestionAnsweredEvent(
-        input.questionId,
-        answerId,
-        input.fromMemberId,
-        content.preview
-      );
-      await this.deps.onQuestionAnswered(event);
-    }
-    return {
-      answerId,
-      questionId: input.questionId,
-      deliveredToMemberId: question.fromMemberId,
-      createdAt: answer.createdAt
-    };
-  }
-};
-
-// src/infrastructure/repositories/in-memory-member.repository.ts
-var InMemoryMemberRepository = class {
-  members = /* @__PURE__ */ new Map();
-  async save(member) {
-    this.members.set(member.id, member);
-  }
-  async findById(id) {
-    return this.members.get(id) ?? null;
   }
-  async findByTeamId(teamId) {
-    return [...this.members.values()].filter((m) => m.teamId === teamId);
+  getPeerByTeam(teamName) {
+    return this.peersByTeam.get(teamName);
   }
-  async findOnlineByTeamId(teamId) {
-    return [...this.members.values()].filter((m) => m.teamId === teamId && m.isOnline);
+  onPeerFound(cb) {
+    this.onPeerFoundCb = cb;
   }
-  async delete(id) {
-    return this.members.delete(id);
+  onPeerLost(cb) {
+    this.onPeerLostCb = cb;
   }
-  async exists(id) {
-    return this.members.has(id);
-  }
-  async findAll() {
-    return [...this.members.values()];
-  }
-  /**
-   * Clears all data (useful for testing)
-   */
-  clear() {
-    this.members.clear();
-  }
-  /**
-   * Gets the count of members
-   */
-  get count() {
-    return this.members.size;
+  destroy() {
+    this.mdns.destroy();
   }
 };
 
-// src/domain/entities/team.entity.ts
-var Team = class _Team {
-  _id;
-  _name;
-  _createdAt;
-  _memberIds;
-  constructor(props) {
-    this._id = props.id;
-    this._name = props.name;
-    this._createdAt = props.createdAt;
-    this._memberIds = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Creates a new Team instance
-   */
-  static create(props) {
-    if (!props.name.trim()) {
-      throw new Error("Team name cannot be empty");
-    }
-    return new _Team(props);
-  }
-  /**
-   * Reconstitutes a Team from persistence
-   */
-  static reconstitute(props) {
-    const team = new _Team(props);
-    for (const memberId of props.memberIds) {
-      team._memberIds.add(memberId);
-    }
-    return team;
-  }
-  // Getters
-  get id() {
-    return this._id;
-  }
-  get name() {
-    return this._name;
-  }
-  get createdAt() {
-    return this._createdAt;
-  }
-  get memberIds() {
-    return this._memberIds;
-  }
-  get memberCount() {
-    return this._memberIds.size;
-  }
-  get isEmpty() {
-    return this._memberIds.size === 0;
-  }
-  // Behaviors
-  /**
-   * Adds a member to the team
-   * @returns true if the member was added, false if already present
-   */
-  addMember(memberId) {
-    if (this._memberIds.has(memberId)) {
-      return false;
-    }
-    this._memberIds.add(memberId);
-    return true;
-  }
-  /**
-   * Removes a member from the team
-   * @returns true if the member was removed, false if not present
-   */
-  removeMember(memberId) {
-    return this._memberIds.delete(memberId);
-  }
-  /**
-   * Checks if a member is in the team
-   */
-  hasMember(memberId) {
-    return this._memberIds.has(memberId);
-  }
-  /**
-   * Gets all member IDs except the specified one
-   * Useful for broadcasting to other team members
-   */
-  getOtherMemberIds(excludeMemberId) {
-    return [...this._memberIds].filter((id) => id !== excludeMemberId);
-  }
-  /**
-   * Converts entity to plain object for serialization
-   */
-  toJSON() {
-    return {
-      id: this._id,
-      name: this._name,
-      createdAt: this._createdAt,
-      memberIds: [...this._memberIds]
-    };
-  }
-};
+// src/infrastructure/p2p/p2p-message-protocol.ts
+function serializeP2PMsg(msg) {
+  return JSON.stringify(msg);
+}
+function parseP2PMsg(data) {
+  return JSON.parse(data);
+}
+var CS_CONINJECT = `
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
 
-// src/infrastructure/repositories/in-memory-team.repository.ts
-var InMemoryTeamRepository = class {
-  teams = /* @__PURE__ */ new Map();
-  async save(team) {
-    this.teams.set(team.id, team);
-  }
-  async findById(id) {
-    return this.teams.get(id) ?? null;
-  }
-  async findByName(name) {
-    const teamId = createTeamId(name);
-    return this.teams.get(teamId) ?? null;
-  }
-  async getOrCreate(name) {
-    const existing = await this.findByName(name);
-    if (existing) {
-      return existing;
-    }
-    const teamId = createTeamId(name);
-    const team = Team.create({
-      id: teamId,
-      name: name.trim(),
-      createdAt: /* @__PURE__ */ new Date()
-    });
-    await this.save(team);
-    return team;
-  }
-  async delete(id) {
-    return this.teams.delete(id);
-  }
-  async exists(id) {
-    return this.teams.has(id);
-  }
-  async findAll() {
-    return [...this.teams.values()];
-  }
-  async findNonEmpty() {
-    return [...this.teams.values()].filter((t) => !t.isEmpty);
-  }
-  /**
-   * Clears all data (useful for testing)
-   */
-  clear() {
-    this.teams.clear();
-  }
-  /**
-   * Gets the count of teams
-   */
-  get count() {
-    return this.teams.size;
-  }
-};
+public class ConInject {
+    [DllImport("kernel32.dll")] public static extern bool FreeConsole();
+    [DllImport("kernel32.dll")] public static extern bool AttachConsole(uint pid);
+    [DllImport("kernel32.dll")] public static extern IntPtr GetConsoleWindow();
+    [DllImport("user32.dll")]   public static extern bool SetForegroundWindow(IntPtr hwnd);
+    [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)]
+    public static extern IntPtr CreateFile(
+        string lpFileName, uint dwDesiredAccess, uint dwShareMode,
+        IntPtr lpSecurityAttributes, uint dwCreationDisposition,
+        uint dwFlagsAndAttributes, IntPtr hTemplateFile);
+    [DllImport("kernel32.dll")] public static extern bool WriteConsoleInput(
+        IntPtr hIn, INPUT_RECORD[] buf, uint len, out uint written);
+    [DllImport("kernel32.dll")] public static extern bool CloseHandle(IntPtr h);
 
-// src/infrastructure/repositories/in-memory-question.repository.ts
-var InMemoryQuestionRepository = class {
-  questions = /* @__PURE__ */ new Map();
-  async save(question) {
-    this.questions.set(question.id, question);
-  }
-  async findById(id) {
-    return this.questions.get(id) ?? null;
-  }
-  async findPendingByTeamId(teamId) {
-    return [...this.questions.values()].filter((q) => q.toTeamId === teamId && q.isPending);
-  }
-  async findByFromMemberId(memberId) {
-    return [...this.questions.values()].filter((q) => q.fromMemberId === memberId);
-  }
-  async findPendingByFromMemberId(memberId) {
-    return [...this.questions.values()].filter(
-      (q) => q.fromMemberId === memberId && q.isPending
-    );
-  }
-  async delete(id) {
-    return this.questions.delete(id);
-  }
-  async exists(id) {
-    return this.questions.has(id);
-  }
-  async findAll() {
-    return [...this.questions.values()];
-  }
-  async markTimedOut(olderThanMs) {
-    let count = 0;
-    const now = Date.now();
-    for (const question of this.questions.values()) {
-      if (question.isPending && now - question.createdAt.getTime() > olderThanMs) {
-        question.markAsTimedOut();
-        count++;
-      }
+    [StructLayout(LayoutKind.Explicit, Size=20)]
+    public struct INPUT_RECORD {
+        [FieldOffset(0)]  public ushort EventType;
+        [FieldOffset(4)]  public int    bKeyDown;
+        [FieldOffset(8)]  public ushort wRepeatCount;
+        [FieldOffset(10)] public ushort wVirtualKeyCode;
+        [FieldOffset(12)] public ushort wVirtualScanCode;
+        [FieldOffset(14)] public ushort UnicodeChar;
+        [FieldOffset(16)] public uint   dwControlKeyState;
     }
-    return count;
-  }
-  /**
-   * Clears all data (useful for testing)
-   */
-  clear() {
-    this.questions.clear();
-  }
-  /**
-   * Gets the count of questions
-   */
-  get count() {
-    return this.questions.size;
-  }
-};
 
-// src/infrastructure/repositories/in-memory-answer.repository.ts
-var InMemoryAnswerRepository = class {
-  answers = /* @__PURE__ */ new Map();
-  async save(answer) {
-    this.answers.set(answer.id, answer);
-  }
-  async findById(id) {
-    return this.answers.get(id) ?? null;
-  }
-  async findByQuestionId(questionId) {
-    for (const answer of this.answers.values()) {
-      if (answer.questionId === questionId) {
-        return answer;
-      }
+    const uint LEFT_CTRL = 0x0008;
+
+    static IntPtr OpenConin(uint pid) {
+        FreeConsole();
+        if (!AttachConsole(pid)) return new IntPtr(-1);
+        return CreateFile("CONIN$", 0xC0000000, 3, IntPtr.Zero, 3, 0, IntPtr.Zero);
     }
-    return null;
-  }
-  async findAll() {
-    return [...this.answers.values()];
-  }
-  /**
-   * Clears all data (useful for testing)
-   */
-  clear() {
-    this.answers.clear();
-  }
-  /**
-   * Gets the count of answers
-   */
-  get count() {
-    return this.answers.size;
-  }
-};
 
-// src/infrastructure/websocket/message-protocol.ts
-function serializeMessage(message) {
-  return JSON.stringify(message);
-}
-function parseClientMessage(data) {
-  const parsed = JSON.parse(data);
-  validateClientMessage(parsed);
-  return parsed;
-}
-function parseHubMessage(data) {
-  return JSON.parse(data);
-}
-function validateClientMessage(message) {
-  if (!message.type) {
-    throw new Error("Message must have a type");
-  }
-  const validTypes = ["JOIN", "LEAVE", "ASK", "REPLY", "PING", "GET_INBOX"];
-  if (!validTypes.includes(message.type)) {
-    throw new Error(`Invalid message type: ${message.type}`);
-  }
-}
-function createErrorMessage(code, message, requestId) {
-  return {
-    type: "ERROR",
-    code,
-    message,
-    requestId
-  };
-}
+    // Inject only text characters into console input buffer (no Ctrl keys, no Enter)
+    public static int InjectText(uint pid, string text) {
+        IntPtr hIn = OpenConin(pid);
+        if (hIn == new IntPtr(-1)) return -1;
 
-// src/infrastructure/websocket/hub-server.ts
-function log(level, message, data) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const prefix = `[${timestamp}] [HUB-${level}]`;
-  if (data) {
-    console.log(`${prefix} ${message}`, JSON.stringify(data, null, 2));
-  } else {
-    console.log(`${prefix} ${message}`);
-  }
-}
-var HubServer = class {
-  constructor(options = {}) {
-    this.options = options;
-    this.initializeUseCases();
-  }
-  wss = null;
-  clients = /* @__PURE__ */ new Map();
-  memberToWs = /* @__PURE__ */ new Map();
-  // Repositories
-  memberRepository = new InMemoryMemberRepository();
-  teamRepository = new InMemoryTeamRepository();
-  questionRepository = new InMemoryQuestionRepository();
-  answerRepository = new InMemoryAnswerRepository();
-  // Use cases
-  joinTeamUseCase;
-  askQuestionUseCase;
-  getInboxUseCase;
-  replyQuestionUseCase;
-  heartbeatInterval = null;
-  timeoutCheckInterval = null;
-  initializeUseCases() {
-    this.joinTeamUseCase = new JoinTeamUseCase({
-      memberRepository: this.memberRepository,
-      teamRepository: this.teamRepository,
-      onMemberJoined: async (event) => {
-        await this.broadcastToTeam(event.teamId, event.memberId, {
-          type: "MEMBER_JOINED",
-          member: await this.getMemberInfo(event.memberId)
-        });
-      }
-    });
-    this.askQuestionUseCase = new AskQuestionUseCase({
-      memberRepository: this.memberRepository,
-      teamRepository: this.teamRepository,
-      questionRepository: this.questionRepository,
-      onQuestionAsked: async (event) => {
-        const question = await this.questionRepository.findById(event.questionId);
-        if (question) {
-          await this.deliverQuestion(question);
-        }
-      }
-    });
-    this.getInboxUseCase = new GetInboxUseCase({
-      memberRepository: this.memberRepository,
-      teamRepository: this.teamRepository,
-      questionRepository: this.questionRepository
-    });
-    this.replyQuestionUseCase = new ReplyQuestionUseCase({
-      memberRepository: this.memberRepository,
-      questionRepository: this.questionRepository,
-      answerRepository: this.answerRepository,
-      onQuestionAnswered: async (event) => {
-        const question = await this.questionRepository.findById(event.questionId);
-        const answer = await this.answerRepository.findByQuestionId(event.questionId);
-        if (question && answer) {
-          await this.deliverAnswer(question, answer, event.answeredByMemberId);
-        }
-      }
-    });
-  }
-  /**
-   * Starts the hub server
-   */
-  async start() {
-    const port = this.options.port ?? config.hub.port;
-    const host = this.options.host ?? config.hub.host;
-    return new Promise((resolve, reject) => {
-      try {
-        this.wss = new WebSocketServer({ port, host });
-        this.wss.on("connection", (ws) => {
-          this.handleConnection(ws);
-        });
-        this.wss.on("error", (error) => {
-          log("ERROR", "Hub server error", { error: error.message, stack: error.stack });
-          reject(error);
-        });
-        this.wss.on("listening", () => {
-          log("INFO", `Hub server started successfully`, { host, port });
-          this.startHeartbeat();
-          this.startTimeoutCheck();
-          resolve();
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  /**
-   * Stops the hub server
-   */
-  async stop() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-    }
-    if (this.timeoutCheckInterval) {
-      clearInterval(this.timeoutCheckInterval);
-      this.timeoutCheckInterval = null;
-    }
-    return new Promise((resolve) => {
-      if (this.wss) {
-        for (const [ws] of this.clients) {
-          ws.close();
+        var records = new List<INPUT_RECORD>();
+        foreach (char c in text) {
+            records.Add(new INPUT_RECORD { EventType=1, bKeyDown=1, wRepeatCount=1, UnicodeChar=(ushort)c });
+            records.Add(new INPUT_RECORD { EventType=1, bKeyDown=0, wRepeatCount=1, UnicodeChar=(ushort)c });
         }
-        this.clients.clear();
-        this.memberToWs.clear();
-        this.wss.close(() => {
-          this.wss = null;
-          log("INFO", "Hub server stopped gracefully");
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
-  }
-  handleConnection(ws) {
-    const connection = {
-      ws,
-      lastPing: /* @__PURE__ */ new Date()
-    };
-    this.clients.set(ws, connection);
-    log("INFO", "New client connected", { totalClients: this.clients.size });
-    ws.on("message", async (data) => {
-      await this.handleMessage(ws, data.toString());
-    });
-    ws.on("close", async () => {
-      await this.handleDisconnect(ws);
-    });
-    ws.on("error", (error) => {
-      log("ERROR", "Client connection error", { error: error.message });
-    });
-  }
-  async handleMessage(ws, data) {
-    const connection = this.clients.get(ws);
-    if (!connection) return;
-    try {
-      const message = parseClientMessage(data);
-      connection.lastPing = /* @__PURE__ */ new Date();
-      log("DEBUG", `Received message from client`, {
-        type: message.type,
-        memberId: connection.memberId
-      });
-      switch (message.type) {
-        case "JOIN":
-          await this.handleJoin(ws, connection, message.teamName, message.displayName);
-          break;
-        case "LEAVE":
-          await this.handleLeave(ws, connection);
-          break;
-        case "ASK":
-          await this.handleAsk(ws, connection, message);
-          break;
-        case "REPLY":
-          await this.handleReply(ws, connection, message);
-          break;
-        case "GET_INBOX":
-          await this.handleGetInbox(ws, connection, message.requestId);
-          break;
-        case "PING":
-          this.send(ws, { type: "PONG", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-          break;
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      log("ERROR", "Failed to handle message", {
-        error: errorMessage,
-        memberId: connection.memberId
-      });
-      this.send(ws, createErrorMessage("INVALID_MESSAGE", errorMessage));
-    }
-  }
-  async handleJoin(ws, connection, teamName, displayName) {
-    try {
-      log("INFO", "Member attempting to join", { teamName, displayName });
-      const result = await this.joinTeamUseCase.execute({ teamName, displayName });
-      connection.memberId = result.memberId;
-      connection.teamId = result.teamId;
-      this.memberToWs.set(result.memberId, ws);
-      const memberInfo = await this.getMemberInfo(result.memberId);
-      this.send(ws, {
-        type: "JOINED",
-        member: memberInfo,
-        memberCount: result.memberCount
-      });
-      log("INFO", "Member joined successfully", {
-        memberId: result.memberId,
-        teamName,
-        displayName,
-        memberCount: result.memberCount
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Join failed";
-      log("ERROR", "Member join failed", { teamName, displayName, error: errorMessage });
-      this.send(ws, createErrorMessage("JOIN_FAILED", errorMessage));
-    }
-  }
-  async handleLeave(ws, connection) {
-    if (connection.memberId && connection.teamId) {
-      await this.removeMember(connection.memberId, connection.teamId);
-      connection.memberId = void 0;
-      connection.teamId = void 0;
-    }
-    this.send(ws, { type: "LEFT", memberId: connection.memberId });
-  }
-  async handleAsk(ws, connection, message) {
-    if (!connection.memberId) {
-      log("WARN", "ASK attempt without joining team", { toTeam: message.toTeam });
-      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first", message.requestId));
-      return;
-    }
-    try {
-      log("INFO", "Question asked", {
-        fromMemberId: connection.memberId,
-        toTeam: message.toTeam,
-        contentPreview: message.content.substring(0, 50) + "..."
-      });
-      const result = await this.askQuestionUseCase.execute({
-        fromMemberId: connection.memberId,
-        toTeamName: message.toTeam,
-        content: message.content,
-        format: message.format
-      });
-      this.send(ws, {
-        type: "QUESTION_SENT",
-        questionId: result.questionId,
-        toTeamId: result.toTeamId,
-        status: result.status,
-        requestId: message.requestId
-      });
-      log("INFO", "Question sent successfully", {
-        questionId: result.questionId,
-        fromMemberId: connection.memberId,
-        toTeamId: result.toTeamId
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Ask failed";
-      log("ERROR", "Question failed", {
-        fromMemberId: connection.memberId,
-        toTeam: message.toTeam,
-        error: errorMessage
-      });
-      this.send(ws, createErrorMessage("ASK_FAILED", errorMessage, message.requestId));
-    }
-  }
-  async handleReply(ws, connection, message) {
-    if (!connection.memberId) {
-      log("WARN", "REPLY attempt without joining team", { questionId: message.questionId });
-      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first"));
-      return;
-    }
-    try {
-      log("INFO", "Reply received", {
-        fromMemberId: connection.memberId,
-        questionId: message.questionId,
-        contentPreview: message.content.substring(0, 50) + "..."
-      });
-      await this.replyQuestionUseCase.execute({
-        fromMemberId: connection.memberId,
-        questionId: message.questionId,
-        content: message.content,
-        format: message.format
-      });
-      log("INFO", "Reply delivered successfully", {
-        fromMemberId: connection.memberId,
-        questionId: message.questionId
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Reply failed";
-      log("ERROR", "Reply failed", {
-        fromMemberId: connection.memberId,
-        questionId: message.questionId,
-        error: errorMessage
-      });
-      this.send(ws, createErrorMessage("REPLY_FAILED", errorMessage));
-    }
-  }
-  async handleGetInbox(ws, connection, requestId) {
-    if (!connection.memberId || !connection.teamId) {
-      this.send(ws, createErrorMessage("NOT_JOINED", "Must join a team first", requestId));
-      return;
-    }
-    try {
-      const result = await this.getInboxUseCase.execute({
-        memberId: connection.memberId,
-        teamId: connection.teamId
-      });
-      const questions = await Promise.all(
-        result.questions.map(async (q) => ({
-          questionId: q.questionId,
-          from: await this.getMemberInfo(q.fromMemberId),
-          content: q.content,
-          format: q.format,
-          status: q.status,
-          createdAt: q.createdAt.toISOString(),
-          ageMs: q.ageMs
-        }))
-      );
-      this.send(ws, {
-        type: "INBOX",
-        questions,
-        totalCount: result.totalCount,
-        pendingCount: result.pendingCount,
-        requestId
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Get inbox failed";
-      this.send(ws, createErrorMessage("INBOX_FAILED", errorMessage, requestId));
-    }
-  }
-  async handleDisconnect(ws) {
-    const connection = this.clients.get(ws);
-    if (connection?.memberId && connection.teamId) {
-      log("INFO", "Client disconnecting", {
-        memberId: connection.memberId,
-        teamId: connection.teamId
-      });
-      await this.removeMember(connection.memberId, connection.teamId);
-      this.memberToWs.delete(connection.memberId);
-    }
-    this.clients.delete(ws);
-    log("INFO", "Client disconnected", { totalClients: this.clients.size });
-  }
-  async removeMember(memberId, teamId) {
-    const member = await this.memberRepository.findById(memberId);
-    if (member) {
-      member.goOffline();
-      await this.memberRepository.save(member);
-    }
-    const team = await this.teamRepository.findById(teamId);
-    if (team) {
-      team.removeMember(memberId);
-      await this.teamRepository.save(team);
-      await this.broadcastToTeam(teamId, memberId, {
-        type: "MEMBER_LEFT",
-        memberId,
-        teamId
-      });
-    }
-  }
-  async deliverQuestion(question) {
-    const team = await this.teamRepository.findById(question.toTeamId);
-    if (!team) {
-      log("WARN", "Cannot deliver question - team not found", { toTeamId: question.toTeamId });
-      return;
-    }
-    const fromMember = await this.memberRepository.findById(question.fromMemberId);
-    if (!fromMember) {
-      log("WARN", "Cannot deliver question - from member not found", {
-        fromMemberId: question.fromMemberId
-      });
-      return;
-    }
-    const memberInfo = await this.getMemberInfo(question.fromMemberId);
-    let deliveredCount = 0;
-    for (const memberId of team.memberIds) {
-      const ws = this.memberToWs.get(memberId);
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        this.send(ws, {
-          type: "QUESTION",
-          questionId: question.id,
-          from: memberInfo,
-          content: question.content.text,
-          format: question.content.format,
-          createdAt: question.createdAt.toISOString()
-        });
-        deliveredCount++;
-      }
-    }
-    log("INFO", "Question delivered to team", {
-      questionId: question.id,
-      toTeamId: question.toTeamId,
-      teamSize: team.memberIds.size,
-      deliveredCount
-    });
-  }
-  async deliverAnswer(question, answer, answeredByMemberId) {
-    const ws = this.memberToWs.get(question.fromMemberId);
-    if (!ws || ws.readyState !== WebSocket.OPEN) {
-      log("WARN", "Cannot deliver answer - questioner not connected", {
-        questionId: question.id,
-        fromMemberId: question.fromMemberId
-      });
-      return;
-    }
-    const memberInfo = await this.getMemberInfo(answeredByMemberId);
-    this.send(ws, {
-      type: "ANSWER",
-      questionId: question.id,
-      from: memberInfo,
-      content: answer.content.text,
-      format: answer.content.format,
-      answeredAt: answer.createdAt.toISOString()
-    });
-    log("INFO", "Answer delivered", {
-      questionId: question.id,
-      answeredBy: answeredByMemberId,
-      deliveredTo: question.fromMemberId
-    });
-  }
-  async broadcastToTeam(teamId, excludeMemberId, message) {
-    const team = await this.teamRepository.findById(teamId);
-    if (!team) return;
-    for (const memberId of team.getOtherMemberIds(excludeMemberId)) {
-      const ws = this.memberToWs.get(memberId);
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        this.send(ws, message);
-      }
-    }
-  }
-  async getMemberInfo(memberId) {
-    const member = await this.memberRepository.findById(memberId);
-    const team = member ? await this.teamRepository.findById(member.teamId) : null;
-    return {
-      memberId,
-      teamId: member?.teamId ?? "",
-      teamName: team?.name ?? "Unknown",
-      displayName: member?.displayName ?? "Unknown",
-      status: member?.status ?? "OFFLINE" /* OFFLINE */
-    };
-  }
-  send(ws, message) {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(serializeMessage(message));
+
+        var arr = records.ToArray();
+        uint written;
+        bool ok = WriteConsoleInput(hIn, arr, (uint)arr.Length, out written);
+        CloseHandle(hIn);
+        return ok ? (int)written : -2;
     }
-  }
-  startHeartbeat() {
-    this.heartbeatInterval = setInterval(() => {
-      const now = /* @__PURE__ */ new Date();
-      for (const [ws, connection] of this.clients) {
-        const timeSinceLastPing = now.getTime() - connection.lastPing.getTime();
-        if (timeSinceLastPing > config.hub.clientTimeout) {
-          ws.terminate();
+
+    // Focus the console window for WScript.Shell.SendKeys
+    public static IntPtr FocusConsole(uint pid) {
+        FreeConsole();
+        if (!AttachConsole(pid)) return IntPtr.Zero;
+        IntPtr hwnd = GetConsoleWindow();
+        if (hwnd != IntPtr.Zero) SetForegroundWindow(hwnd);
+        return hwnd;
+    }
+}
+`;
+function buildScript(claudePid, body) {
+  const logFile = join(tmpdir(), `cc-inject-${Date.now()}.log`).replace(/\\/g, "/");
+  return `
+$log = "${logFile}"
+function Log($msg) { Add-Content -Path $log -Value $msg -Encoding UTF8 }
+$claudePid = ${claudePid}
+try { Add-Type @'${CS_CONINJECT}'@ } catch { }
+${body}
+`;
+}
+function run(script) {
+  return new Promise((resolve) => {
+    const encoded = Buffer.from(script, "utf16le").toString("base64");
+    execFile(
+      "powershell",
+      ["-NoProfile", "-WindowStyle", "Hidden", "-EncodedCommand", encoded],
+      { windowsHide: true },
+      () => {
+        const logFile = script.match(/\$log = "([^"]+)"/)?.[1];
+        if (logFile) try {
+          unlinkSync(logFile);
+        } catch {
         }
+        resolve();
       }
-    }, config.hub.heartbeatInterval);
-  }
-  startTimeoutCheck() {
-    this.timeoutCheckInterval = setInterval(async () => {
-      await this.questionRepository.markTimedOut(config.communication.defaultTimeout);
-    }, 5e3);
-  }
+    );
+  });
+}
+async function windowsInject(text) {
+  const claudePid = process.ppid;
+  const textB64 = Buffer.from(text, "utf16le").toString("base64");
+  const script = buildScript(claudePid, `
+$textBytes = [System.Convert]::FromBase64String('${textB64}')
+$text = [System.Text.Encoding]::Unicode.GetString($textBytes)
+$wsh = New-Object -ComObject WScript.Shell
+
+# 1. Focus console and send Ctrl+U to save user's current text to kill ring
+$hwnd = [ConInject]::FocusConsole([uint32]$claudePid)
+Start-Sleep -Milliseconds 150
+$wsh.SendKeys('^u')
+Start-Sleep -Milliseconds 150
+
+# 2. Write question text into console input buffer
+[ConInject]::InjectText([uint32]$claudePid, $text) | Out-Null
+
+# 3. Re-focus (InjectText calls FreeConsole internally, focus may be lost)
+[ConInject]::FocusConsole([uint32]$claudePid) | Out-Null
+Start-Sleep -Milliseconds 150
+
+# 4. Send Enter
+$wsh.SendKeys('~')
+`);
+  await run(script);
+}
+async function windowsInjectCtrlY() {
+  const claudePid = process.ppid;
+  const script = buildScript(claudePid, `
+$wsh = New-Object -ComObject WScript.Shell
+$hwnd = [ConInject]::FocusConsole([uint32]$claudePid)
+Start-Sleep -Milliseconds 150
+$wsh.SendKeys('^y')
+`);
+  await run(script);
+}
+
+// src/infrastructure/terminal-injector/index.ts
+function formatQuestionForInjection(question) {
+  const content = question.content.replace(/\s+/g, " ").trim();
+  return `[HUB SORUSU] ID:${question.questionId} | ${question.from.displayName} (${question.from.teamName}): ${content} | Cevapla ve reply tool ile "${question.questionId}" ID'sine g\xF6nder, onay bekleme.`;
+}
+async function injectQuestionToTerminal(question) {
+  if (process.platform !== "win32") return;
+  const text = formatQuestionForInjection(question);
+  await windowsInject(text);
+}
+async function injectRestoreText() {
+  if (process.platform !== "win32") return;
+  await windowsInjectCtrlY();
+}
+
+// src/infrastructure/terminal-injector/injection-queue.ts
+var REPLY_TIMEOUT_MS = 5 * 60 * 1e3;
+var InjectionQueue = class extends EventEmitter {
+  queue = [];
+  processing = false;
   /**
-   * Gets the number of connected clients
+   * Add a question to the queue. Starts processing if idle.
    */
-  get clientCount() {
-    return this.clients.size;
+  enqueue(question) {
+    this.queue.push(question);
+    if (!this.processing) void this.processNext();
   }
   /**
-   * Checks if the server is running
+   * Called by the reply tool after a reply is successfully sent.
+   * Unblocks the queue to process the next question.
    */
-  get isRunning() {
-    return this.wss !== null;
+  notifyReplied() {
+    this.emit("replied");
   }
-};
-var HubClient = class {
-  constructor(options = {}, events = {}) {
-    this.options = options;
-    this.events = events;
-  }
-  ws = null;
-  pendingRequests = /* @__PURE__ */ new Map();
-  reconnectAttempts = 0;
-  isClosing = false;
-  memberId;
-  teamId;
-  teamName;
-  displayName;
-  /**
-   * Connects to the Hub server
-   */
-  async connect() {
-    const host = this.options.host ?? config.hub.host;
-    const port = this.options.port ?? config.hub.port;
-    const url = `ws://${host}:${port}`;
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket2(url);
-        this.ws.on("open", () => {
-          this.reconnectAttempts = 0;
-          this.startPingInterval();
-          this.events.onConnected?.();
-          resolve();
-        });
-        this.ws.on("message", (data) => {
-          this.handleMessage(data.toString());
-        });
-        this.ws.on("close", () => {
-          this.handleDisconnect();
-        });
-        this.ws.on("error", (error) => {
-          this.events.onError?.(error);
-          if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) {
-            reject(error);
-          }
-        });
-      } catch (error) {
-        reject(error);
-      }
+  async processNext() {
+    if (this.queue.length === 0) {
+      this.processing = false;
+      return;
+    }
+    this.processing = true;
+    const question = this.queue.shift();
+    await injectQuestionToTerminal(question);
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, REPLY_TIMEOUT_MS);
+      this.once("replied", () => {
+        clearTimeout(timer);
+        resolve();
+      });
     });
+    await injectRestoreText();
+    void this.processNext();
   }
+};
+var injectionQueue = new InjectionQueue();
+
+// src/config/index.ts
+var config = {
   /**
-   * Disconnects from the Hub server
+   * P2P node configuration
    */
-  async disconnect() {
-    this.isClosing = true;
-    if (this.memberId) {
-      this.send({ type: "LEAVE" });
-    }
-    return new Promise((resolve) => {
-      if (this.ws) {
-        this.ws.close();
-        this.ws = null;
-      }
-      this.isClosing = false;
-      resolve();
+  p2p: {
+    /**
+     * Minimum port for the random WS server port range
+     */
+    portRangeMin: 1e4,
+    /**
+     * Maximum port for the random WS server port range
+     */
+    portRangeMax: 19999
+  }};
+
+// src/infrastructure/p2p/p2p-node.ts
+function getRandomPort(min, max) {
+  return new Promise((resolve) => {
+    const port = Math.floor(Math.random() * (max - min + 1)) + min;
+    const server = createServer();
+    server.listen(port, () => {
+      server.close(() => resolve(port));
+    });
+    server.on("error", () => {
+      resolve(getRandomPort(min, max));
     });
+  });
+}
+var P2PNode = class {
+  wss = null;
+  mdnsDiscovery = null;
+  port = 0;
+  // Connections indexed by remote team name
+  peerConns = /* @__PURE__ */ new Map();
+  // Reverse lookup: ws → teamName (for cleanup on incoming connections)
+  wsToTeam = /* @__PURE__ */ new Map();
+  // Questions we received from remote peers (our inbox)
+  incomingQuestions = /* @__PURE__ */ new Map();
+  // Answers we received for questions we asked
+  receivedAnswers = /* @__PURE__ */ new Map();
+  // Maps questionId → remote teamName (so we know who to poll)
+  questionToTeam = /* @__PURE__ */ new Map();
+  // Pending response handlers (request-response correlation by filter)
+  pendingHandlers = /* @__PURE__ */ new Set();
+  localMember = null;
+  _isStarted = false;
+  get isConnected() {
+    return this._isStarted;
+  }
+  get currentTeamId() {
+    return this.localMember?.teamName;
   }
   /**
-   * Joins a team
+   * Starts the WS server on a random port and initialises mDNS.
+   * Called automatically from join() if not yet started.
    */
+  async start() {
+    this.port = await getRandomPort(config.p2p.portRangeMin, config.p2p.portRangeMax);
+    this.wss = new WebSocketServer({ port: this.port });
+    this.setupWssHandlers();
+    this.mdnsDiscovery = new MdnsDiscovery();
+    this._isStarted = true;
+    console.error(`P2P node started on port ${this.port}`);
+  }
   async join(teamName, displayName) {
-    v4();
-    this.send({
-      type: "JOIN",
-      teamName,
-      displayName
+    if (!this._isStarted) {
+      await this.start();
+    }
+    const memberId = v4();
+    this.localMember = { memberId, teamName, displayName };
+    this.mdnsDiscovery.onPeerFound((peer) => {
+      if (peer.teamName !== teamName) {
+        console.error(`Discovered peer '${peer.teamName}' at ${peer.host}:${peer.port}`);
+        this.connectToPeer(peer.teamName, peer.host, peer.port).catch((err) => {
+          console.error(`Could not eagerly connect to ${peer.teamName}:`, err);
+        });
+      }
     });
-    const response = await this.waitForResponse(
-      (msg) => msg.type === "JOINED",
-      3e4
-    );
-    this.memberId = response.member.memberId;
-    this.teamId = response.member.teamId;
-    this.teamName = teamName;
-    this.displayName = displayName;
-    return response.member;
+    this.mdnsDiscovery.announce(this.port, teamName, memberId);
+    this.mdnsDiscovery.discover();
+    return { memberId, teamId: teamName, teamName, displayName, status: "ONLINE" };
   }
-  /**
-   * Asks a question to another team
-   */
-  async ask(toTeam, content, format = "markdown", timeoutMs = config.communication.defaultTimeout) {
+  async ask(toTeam, content, format) {
+    const ws = await this.getPeerConnection(toTeam);
+    const questionId = v4();
     const requestId = v4();
-    this.send({
-      type: "ASK",
+    this.questionToTeam.set(questionId, toTeam);
+    const ackPromise = this.waitForResponse(
+      (m) => m.type === "P2P_ASK_ACK" && m.requestId === requestId,
+      5e3
+    );
+    const msg = {
+      type: "P2P_ASK",
+      questionId,
+      fromMemberId: this.localMember.memberId,
+      fromTeam: this.localMember.teamName,
       toTeam,
       content,
       format,
       requestId
-    });
-    const questionSent = await this.waitForResponse(
-      (msg) => msg.type === "QUESTION_SENT" && "requestId" in msg && msg.requestId === requestId,
-      5e3
-    );
-    const questionId = questionSent.questionId;
-    const answer = await this.waitForResponse(
-      (msg) => msg.type === "ANSWER" && msg.questionId === questionId,
-      timeoutMs
-    );
-    return answer;
+    };
+    ws.send(serializeP2PMsg(msg));
+    await ackPromise;
+    return questionId;
   }
-  /**
-   * Gets the inbox (pending questions)
-   */
-  async getInbox() {
+  async checkAnswer(questionId) {
+    const cached = this.receivedAnswers.get(questionId);
+    if (cached) {
+      return {
+        questionId,
+        from: { displayName: `${cached.fromTeam} Claude`, teamName: cached.fromTeam },
+        content: cached.content,
+        format: cached.format,
+        answeredAt: cached.answeredAt
+      };
+    }
+    const toTeam = this.questionToTeam.get(questionId);
+    if (!toTeam) return null;
+    const ws = this.peerConns.get(toTeam);
+    if (!ws || ws.readyState !== WebSocket.OPEN) return null;
     const requestId = v4();
-    this.send({
-      type: "GET_INBOX",
-      requestId
-    });
-    return this.waitForResponse(
-      (msg) => msg.type === "INBOX" && msg.requestId === requestId,
+    const responsePromise = this.waitForResponse(
+      (m) => m.type === "P2P_ANSWER" && m.questionId === questionId || m.type === "P2P_ANSWER_PENDING" && m.requestId === requestId,
       5e3
     );
+    const getMsg = {
+      type: "P2P_GET_ANSWER",
+      questionId,
+      requestId
+    };
+    ws.send(serializeP2PMsg(getMsg));
+    const response = await responsePromise;
+    if (response.type === "P2P_ANSWER_PENDING") return null;
+    const answer = response;
+    this.receivedAnswers.set(questionId, {
+      content: answer.content,
+      format: answer.format,
+      answeredAt: answer.answeredAt,
+      fromTeam: answer.fromTeam,
+      fromMemberId: answer.fromMemberId
+    });
+    return {
+      questionId,
+      from: { displayName: `${answer.fromTeam} Claude`, teamName: answer.fromTeam },
+      content: answer.content,
+      format: answer.format,
+      answeredAt: answer.answeredAt
+    };
   }
-  /**
-   * Replies to a question
-   */
-  async reply(questionId, content, format = "markdown") {
-    this.send({
-      type: "REPLY",
+  async reply(questionId, content, format) {
+    const question = this.incomingQuestions.get(questionId);
+    if (!question) throw new Error(`Question ${questionId} not found in inbox`);
+    question.answered = true;
+    question.answerContent = content;
+    question.answerFormat = format;
+    const answerMsg = {
+      type: "P2P_ANSWER",
       questionId,
       content,
-      format
-    });
+      format,
+      answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      fromTeam: this.localMember.teamName,
+      fromMemberId: this.localMember.memberId
+    };
+    if (question.ws.readyState === WebSocket.OPEN) {
+      question.ws.send(serializeP2PMsg(answerMsg));
+    }
   }
-  /**
-   * Checks if connected
-   */
-  get isConnected() {
-    return this.ws !== null && this.ws.readyState === WebSocket2.OPEN;
+  async getInbox() {
+    const now = Date.now();
+    const questions = [...this.incomingQuestions.values()].filter((q) => !q.answered).map((q) => ({
+      questionId: q.questionId,
+      from: { displayName: `${q.fromTeam} Claude`, teamName: q.fromTeam },
+      content: q.content,
+      format: q.format,
+      status: "PENDING",
+      createdAt: q.createdAt.toISOString(),
+      ageMs: now - q.createdAt.getTime()
+    }));
+    return {
+      questions,
+      totalCount: questions.length,
+      pendingCount: questions.length
+    };
   }
-  /**
-   * Gets the current member ID
-   */
-  get currentMemberId() {
-    return this.memberId;
+  async disconnect() {
+    this.mdnsDiscovery?.destroy();
+    for (const ws of this.peerConns.values()) {
+      ws.close();
+    }
+    this.peerConns.clear();
+    await new Promise((resolve) => {
+      if (this.wss) {
+        this.wss.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+    this._isStarted = false;
+  }
+  // ---------------------------------------------------------------------------
+  // Private: WebSocket server setup
+  // ---------------------------------------------------------------------------
+  setupWssHandlers() {
+    this.wss.on("connection", (ws) => {
+      ws.on("message", (data) => {
+        try {
+          const msg = parseP2PMsg(data.toString());
+          this.handleMessage(ws, msg);
+        } catch (err) {
+          console.error("Failed to parse incoming P2P message:", err);
+        }
+      });
+      ws.on("close", () => {
+        const team = this.wsToTeam.get(ws);
+        if (team) {
+          if (this.peerConns.get(team) === ws) {
+            this.peerConns.delete(team);
+          }
+          this.wsToTeam.delete(ws);
+        }
+      });
+    });
   }
-  /**
-   * Gets the current team ID
-   */
-  get currentTeamId() {
-    return this.teamId;
+  // ---------------------------------------------------------------------------
+  // Private: unified message handler (used for both incoming & outgoing sockets)
+  // ---------------------------------------------------------------------------
+  handleMessage(ws, msg) {
+    for (const handler of this.pendingHandlers) {
+      handler(msg);
+    }
+    switch (msg.type) {
+      case "P2P_HELLO":
+        this.wsToTeam.set(ws, msg.fromTeam);
+        this.peerConns.set(msg.fromTeam, ws);
+        console.error(`Peer identified: ${msg.fromTeam}`);
+        break;
+      case "P2P_ASK":
+        this.handleIncomingAsk(ws, msg);
+        break;
+      case "P2P_GET_ANSWER":
+        this.handleGetAnswer(ws, msg);
+        break;
+      case "P2P_ANSWER":
+        if (!this.receivedAnswers.has(msg.questionId)) {
+          this.receivedAnswers.set(msg.questionId, {
+            content: msg.content,
+            format: msg.format,
+            answeredAt: msg.answeredAt,
+            fromTeam: msg.fromTeam,
+            fromMemberId: msg.fromMemberId
+          });
+        }
+        break;
+      case "P2P_PING":
+        ws.send(serializeP2PMsg({ type: "P2P_PONG" }));
+        break;
+    }
+  }
+  handleIncomingAsk(ws, msg) {
+    this.incomingQuestions.set(msg.questionId, {
+      questionId: msg.questionId,
+      fromTeam: msg.fromTeam,
+      fromMemberId: msg.fromMemberId,
+      content: msg.content,
+      format: msg.format,
+      createdAt: /* @__PURE__ */ new Date(),
+      ws,
+      answered: false
+    });
+    injectionQueue.enqueue({
+      questionId: msg.questionId,
+      from: {
+        displayName: `${msg.fromTeam} Claude`,
+        teamName: msg.fromTeam
+      },
+      content: msg.content,
+      format: msg.format,
+      status: "PENDING",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ageMs: 0
+    });
+    const ack = {
+      type: "P2P_ASK_ACK",
+      questionId: msg.questionId,
+      requestId: msg.requestId
+    };
+    ws.send(serializeP2PMsg(ack));
   }
-  send(message) {
-    if (this.ws && this.ws.readyState === WebSocket2.OPEN) {
-      this.ws.send(serializeMessage(message));
+  handleGetAnswer(ws, msg) {
+    const question = this.incomingQuestions.get(msg.questionId);
+    if (!question?.answered) {
+      const pending = {
+        type: "P2P_ANSWER_PENDING",
+        questionId: msg.questionId,
+        requestId: msg.requestId
+      };
+      ws.send(serializeP2PMsg(pending));
+      return;
+    }
+    const answer = {
+      type: "P2P_ANSWER",
+      questionId: msg.questionId,
+      content: question.answerContent,
+      format: question.answerFormat,
+      answeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      fromTeam: this.localMember.teamName,
+      fromMemberId: this.localMember.memberId,
+      requestId: msg.requestId
+    };
+    ws.send(serializeP2PMsg(answer));
+  }
+  // ---------------------------------------------------------------------------
+  // Private: peer connection management
+  // ---------------------------------------------------------------------------
+  async getPeerConnection(teamName) {
+    const existing = this.peerConns.get(teamName);
+    if (existing && existing.readyState === WebSocket.OPEN) {
+      return existing;
+    }
+    let peer = this.mdnsDiscovery?.getPeerByTeam(teamName);
+    if (!peer) {
+      this.mdnsDiscovery?.discover();
+      await this.waitForMdnsPeer(teamName, 1e4);
+      peer = this.mdnsDiscovery?.getPeerByTeam(teamName);
+    }
+    if (!peer) {
+      throw new Error(
+        `Peer for team '${teamName}' not found via mDNS. Make sure the other terminal has joined with that team name.`
+      );
     }
+    return this.connectToPeer(teamName, peer.host, peer.port);
   }
-  handleMessage(data) {
-    try {
-      const message = parseHubMessage(data);
-      for (const [requestId, pending] of this.pendingRequests) {
+  async connectToPeer(teamName, host, port) {
+    const existing = this.peerConns.get(teamName);
+    if (existing && existing.readyState === WebSocket.OPEN) {
+      return existing;
+    }
+    const ws = new WebSocket(`ws://${host}:${port}`);
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error(`Connection timeout to team '${teamName}'`)),
+        5e3
+      );
+      ws.on("open", () => {
+        clearTimeout(timeout);
+        const hello = {
+          type: "P2P_HELLO",
+          fromTeam: this.localMember?.teamName ?? "unknown",
+          fromMemberId: this.localMember?.memberId ?? "unknown"
+        };
+        ws.send(serializeP2PMsg(hello));
+        resolve();
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+    ws.on("message", (data) => {
+      try {
+        const msg = parseP2PMsg(data.toString());
+        this.handleMessage(ws, msg);
+      } catch (err) {
+        console.error("Failed to parse P2P message:", err);
       }
-      switch (message.type) {
-        case "QUESTION":
-          this.events.onQuestion?.(message);
-          break;
-        case "ANSWER":
-          this.events.onAnswer?.(message);
-          break;
-        case "MEMBER_JOINED":
-          this.events.onMemberJoined?.(message.member);
-          break;
-        case "MEMBER_LEFT":
-          this.events.onMemberLeft?.(message.memberId, message.teamId);
-          break;
-        case "ERROR":
-          this.events.onError?.(new Error(`${message.code}: ${message.message}`));
-          break;
+    });
+    ws.on("close", () => {
+      if (this.peerConns.get(teamName) === ws) {
+        this.peerConns.delete(teamName);
       }
-      this.resolvePendingRequest(message);
-    } catch (error) {
-      console.error("Failed to parse message:", error);
-    }
+    });
+    this.peerConns.set(teamName, ws);
+    return ws;
   }
-  resolvePendingRequest(message) {
-    for (const [requestId, pending] of this.pendingRequests) {
-      this.pendingRequests.delete(requestId);
-      clearTimeout(pending.timeout);
-      pending.resolve(message);
-      break;
-    }
+  waitForMdnsPeer(teamName, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const deadline = Date.now() + timeoutMs;
+      const check = () => {
+        if (this.mdnsDiscovery?.getPeerByTeam(teamName)) {
+          resolve();
+          return;
+        }
+        if (Date.now() >= deadline) {
+          reject(new Error(`mDNS timeout: team '${teamName}' not found`));
+          return;
+        }
+        this.mdnsDiscovery?.discover();
+        setTimeout(check, 500);
+      };
+      check();
+    });
   }
   waitForResponse(filter, timeoutMs) {
     return new Promise((resolve, reject) => {
-      const requestId = v4();
       const timeout = setTimeout(() => {
-        this.pendingRequests.delete(requestId);
-        reject(new Error("Request timed out"));
+        this.pendingHandlers.delete(handler);
+        reject(new Error("P2P request timed out"));
       }, timeoutMs);
-      const pending = {
-        resolve: (msg) => {
-          if (filter(msg)) {
-            resolve(msg);
-          }
-        },
-        reject,
-        timeout,
-        filter
-      };
-      this.pendingRequests.set(requestId, pending);
-      const originalHandler = this.handleMessage.bind(this);
-      const checkFilter = (data) => {
-        try {
-          const message = parseHubMessage(data);
-          if (filter(message)) {
-            this.pendingRequests.delete(requestId);
-            clearTimeout(timeout);
-            resolve(message);
-          }
-        } catch {
+      const handler = (msg) => {
+        if (filter(msg)) {
+          clearTimeout(timeout);
+          this.pendingHandlers.delete(handler);
+          resolve(msg);
         }
-        originalHandler(data);
       };
-      if (this.ws) {
-        this.ws.removeAllListeners("message");
-        this.ws.on("message", (data) => checkFilter(data.toString()));
-      }
+      this.pendingHandlers.add(handler);
     });
   }
-  handleDisconnect() {
-    this.events.onDisconnected?.();
-    if (this.isClosing) return;
-    const shouldReconnect = this.options.reconnect ?? true;
-    const maxAttempts = this.options.maxReconnectAttempts ?? config.autoStart.maxRetries;
-    if (shouldReconnect && this.reconnectAttempts < maxAttempts) {
-      this.reconnectAttempts++;
-      const delay = this.options.reconnectDelay ?? config.autoStart.retryDelay;
-      setTimeout(() => {
-        this.connect().then(() => {
-          if (this.teamName && this.displayName) {
-            return this.join(this.teamName, this.displayName);
-          }
-        }).catch((error) => {
-          this.events.onError?.(error);
-        });
-      }, delay);
-    }
-  }
-  pingInterval = null;
-  startPingInterval() {
-    this.pingInterval = setInterval(() => {
-      this.send({ type: "PING" });
-    }, config.hub.heartbeatInterval);
-  }
 };
 var joinSchema = {
   team: z.string().describe('Team name to join (e.g., "frontend", "backend", "devops")'),
   displayName: z.string().optional().describe('Display name for this terminal (default: team + " Claude")')
 };
-function registerJoinTool(server, hubClient) {
+function registerJoinTool(server, client) {
   server.tool("join", joinSchema, async (args) => {
     const teamName = args.team;
     const displayName = args.displayName ?? `${teamName} Claude`;
     try {
-      if (!hubClient.isConnected) {
-        await hubClient.connect();
-      }
-      const member = await hubClient.join(teamName, displayName);
+      const member = await client.join(teamName, displayName);
       return {
         content: [
           {
@@ -1845,16 +796,14 @@ Status: ${member.status}`
 }
 var askSchema = {
   team: z.string().describe('Target team name to ask (e.g., "backend", "frontend")'),
-  question: z.string().describe("The question to ask (supports markdown)"),
-  timeout: z.number().optional().describe(`Timeout in seconds to wait for answer (default: ${config.communication.defaultTimeout / 1e3}s)`)
+  question: z.string().describe("The question to ask (supports markdown)")
 };
-function registerAskTool(server, hubClient) {
+function registerAskTool(server, client) {
   server.tool("ask", askSchema, async (args) => {
     const targetTeam = args.team;
     const question = args.question;
-    const timeoutMs = (args.timeout ?? config.communication.defaultTimeout / 1e3) * 1e3;
     try {
-      if (!hubClient.currentTeamId) {
+      if (!client.currentTeamId) {
         return {
           content: [
             {
@@ -1865,25 +814,76 @@ function registerAskTool(server, hubClient) {
           isError: true
         };
       }
-      const answer = await hubClient.ask(targetTeam, question, "markdown", timeoutMs);
+      const questionId = await client.ask(targetTeam, question, "markdown");
+      const POLL_INTERVAL_MS = 5e3;
+      const MAX_WAIT_MS = 5 * 60 * 1e3;
+      const deadline = Date.now() + MAX_WAIT_MS;
+      while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        const answer = await client.checkAnswer(questionId);
+        if (answer !== null) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `**${answer.from.displayName} (${answer.from.teamName}) cevaplad\u0131:**
+
+${answer.content}`
+              }
+            ]
+          };
+        }
+      }
       return {
         content: [
           {
             type: "text",
-            text: `**Answer from ${answer.from.displayName} (${answer.from.teamName}):**
+            text: `Soru g\xF6nderildi ancak 5 dakika i\xE7inde cevap gelmedi.
+Question ID: \`${questionId}\`
 
-${answer.content}`
+Manuel kontrol i\xE7in "check_answer" tool'unu kullanabilirsin.`
           }
         ]
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (errorMessage.includes("timed out")) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to send question: ${errorMessage}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+}
+var checkAnswerSchema = {
+  question_id: z.string().describe('The question ID returned by the "ask" tool')
+};
+function registerCheckAnswerTool(server, client) {
+  server.tool("check_answer", checkAnswerSchema, async (args) => {
+    const questionId = args.question_id;
+    try {
+      if (!client.currentTeamId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: 'You must join a team first. Use the "join" tool to join a team.'
+            }
+          ],
+          isError: true
+        };
+      }
+      const answer = await client.checkAnswer(questionId);
+      if (!answer) {
         return {
           content: [
             {
               type: "text",
-              text: `No response received from team "${targetTeam}" within ${timeoutMs / 1e3} seconds. The question has been delivered but no one answered yet.`
+              text: `No answer yet for question \`${questionId}\`. The other team hasn't replied yet. You can continue working and check again later.`
             }
           ]
         };
@@ -1892,7 +892,19 @@ ${answer.content}`
         content: [
           {
             type: "text",
-            text: `Failed to ask question: ${errorMessage}`
+            text: `**Answer from ${answer.from.displayName} (${answer.from.teamName}):**
+
+${answer.content}`
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to check answer: ${errorMessage}`
           }
         ],
         isError: true
@@ -1903,10 +915,10 @@ ${answer.content}`
 
 // src/presentation/mcp/tools/inbox.tool.ts
 var inboxSchema = {};
-function registerInboxTool(server, hubClient) {
+function registerInboxTool(server, client) {
   server.tool("inbox", inboxSchema, async () => {
     try {
-      if (!hubClient.currentTeamId) {
+      if (!client.currentTeamId) {
         return {
           content: [
             {
@@ -1917,7 +929,7 @@ function registerInboxTool(server, hubClient) {
           isError: true
         };
       }
-      const inbox = await hubClient.getInbox();
+      const inbox = await client.getInbox();
       if (inbox.questions.length === 0) {
         return {
           content: [
@@ -1969,12 +981,12 @@ var replySchema = {
   questionId: z.string().describe("The ID of the question to reply to (from inbox)"),
   answer: z.string().describe("Your answer to the question (supports markdown)")
 };
-function registerReplyTool(server, hubClient) {
+function registerReplyTool(server, client) {
   server.tool("reply", replySchema, async (args) => {
     const questionId = args.questionId;
     const answer = args.answer;
     try {
-      if (!hubClient.currentTeamId) {
+      if (!client.currentTeamId) {
         return {
           content: [
             {
@@ -1985,7 +997,8 @@ function registerReplyTool(server, hubClient) {
           isError: true
         };
       }
-      await hubClient.reply(questionId, answer, "markdown");
+      await client.reply(questionId, answer, "markdown");
+      injectionQueue.notifyReplied();
       return {
         content: [
           {
@@ -2011,7 +1024,7 @@ function registerReplyTool(server, hubClient) {
 
 // src/presentation/mcp/server.ts
 function createMcpServer(options) {
-  const { hubClient } = options;
+  const { client } = options;
   const server = new McpServer(
     {
       name: "claude-collab",
@@ -2026,26 +1039,18 @@ function createMcpServer(options) {
       }
     }
   );
-  registerJoinTool(server, hubClient);
-  registerAskTool(server, hubClient);
-  registerInboxTool(server, hubClient);
-  registerReplyTool(server, hubClient);
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return {
-      resources: [
-        {
-          uri: "inbox://questions",
-          name: "Pending Questions",
-          description: "Your inbox of pending questions from other teams",
-          mimeType: "application/json"
-        }
-      ]
-    };
-  });
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    if (request.params.uri === "inbox://questions") {
+  registerJoinTool(server, client);
+  registerAskTool(server, client);
+  registerCheckAnswerTool(server, client);
+  registerInboxTool(server, client);
+  registerReplyTool(server, client);
+  server.resource(
+    "inbox-questions",
+    "inbox://questions",
+    { description: "Your inbox of pending questions from other teams", mimeType: "application/json" },
+    async () => {
       try {
-        const inbox = await hubClient.getInbox();
+        const inbox = await client.getInbox();
         return {
           contents: [
             {
@@ -2060,150 +1065,33 @@ function createMcpServer(options) {
         throw new Error(`Failed to read inbox: ${errorMessage}`);
       }
     }
-    throw new Error(`Unknown resource URI: ${request.params.uri}`);
-  });
+  );
   return server;
 }
 async function startMcpServer(options) {
-  const { hubClient } = options;
   const server = createMcpServer(options);
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  hubClient.events.onQuestion = async (question) => {
-    await server.notification({
-      method: "notifications/resources/updated",
-      params: {
-        uri: "inbox://questions"
-      }
-    });
-    console.error(`[\u{1F4EC} New Question] From: ${question.from.displayName}`);
-    console.error(`[\u{1F4A1} Tip] Check your inbox with: inbox()`);
-  };
-}
-async function isHubRunning(host = config.hub.host, port = config.hub.port) {
-  return new Promise((resolve) => {
-    const socket = createConnection({ host, port }, () => {
-      socket.end();
-      resolve(true);
-    });
-    socket.on("error", () => {
-      resolve(false);
-    });
-    socket.setTimeout(1e3, () => {
-      socket.destroy();
-      resolve(false);
-    });
-  });
-}
-async function waitForHub(host = config.hub.host, port = config.hub.port, maxRetries = config.autoStart.maxRetries, retryDelay = config.autoStart.retryDelay) {
-  for (let i = 0; i < maxRetries; i++) {
-    if (await isHubRunning(host, port)) {
-      return true;
-    }
-    await new Promise((resolve) => setTimeout(resolve, retryDelay));
-  }
-  return false;
-}
-function startHubProcess(options = {}) {
-  const host = options.host ?? config.hub.host;
-  const port = options.port ?? config.hub.port;
-  const hubProcess = spawn(
-    process.execPath,
-    [
-      "--experimental-specifier-resolution=node",
-      new URL("../../hub-main.js", import.meta.url).pathname,
-      "--host",
-      host,
-      "--port",
-      port.toString()
-    ],
-    {
-      detached: true,
-      stdio: "ignore"
-    }
-  );
-  hubProcess.unref();
-  return hubProcess;
-}
-async function ensureHubRunning(options = {}) {
-  const host = options.host ?? config.hub.host;
-  const port = options.port ?? config.hub.port;
-  const maxRetries = options.maxRetries ?? config.autoStart.maxRetries;
-  const retryDelay = options.retryDelay ?? config.autoStart.retryDelay;
-  if (await isHubRunning(host, port)) {
-    return true;
-  }
-  console.log(`Hub not running. Starting hub on ${host}:${port}...`);
-  startHubProcess({ host, port });
-  const isRunning = await waitForHub(host, port, maxRetries, retryDelay);
-  if (isRunning) {
-    console.log("Hub started successfully");
-  } else {
-    console.error("Failed to start hub");
-  }
-  return isRunning;
 }
 
 // src/cli.ts
 var program = new Command();
-program.name("claude-collab").description("Real-time team collaboration between Claude Code terminals").version("0.1.0");
-var hubCmd = program.command("hub").description("Hub server commands");
-hubCmd.command("start").description("Start the Hub server").option("-p, --port <port>", "Port to listen on", String(config.hub.port)).option("--host <host>", "Host to bind to", config.hub.host).action(async (options) => {
-  const port = parseInt(options.port, 10);
-  const host = options.host;
-  const server = new HubServer({ host, port });
-  const shutdown = async () => {
-    console.log("\nShutting down hub server...");
-    await server.stop();
-    process.exit(0);
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+program.name("claude-collab").description("Real-time P2P team collaboration between Claude Code terminals").version("0.1.0");
+program.command("client").description("Start MCP client (P2P mode, connects to Claude Code)").option("-t, --team <team>", "Team to auto-join (e.g., frontend, backend)").action(async (options) => {
+  const p2pNode = new P2PNode();
   try {
-    await server.start();
-    console.log(`Claude Collab Hub Server running on ${host}:${port}`);
+    await p2pNode.start();
+    if (options.team) {
+      await p2pNode.join(options.team, `${options.team} Claude`);
+      console.error(`Auto-joined team: ${options.team}`);
+    }
   } catch (error) {
-    console.error("Failed to start hub server:", error);
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Failed to start P2P node: ${errorMessage}`);
     process.exit(1);
   }
+  await startMcpServer({ client: p2pNode });
 });
-program.command("client").description("Start MCP client (connects to Claude Code)").option("-t, --team <team>", "Team to auto-join (e.g., frontend, backend)").option("--auto-hub", "Auto-start hub if not running", false).option("-p, --port <port>", "Hub port to connect to", String(config.hub.port)).option("--host <host>", "Hub host to connect to", config.hub.host).action(
-  async (options) => {
-    const port = parseInt(options.port, 10);
-    const host = options.host;
-    if (options.autoHub) {
-      const hubRunning = await ensureHubRunning({ host, port });
-      if (!hubRunning) {
-        console.error("Failed to start hub server. Exiting.");
-        process.exit(1);
-      }
-    }
-    const hubClient = new HubClient(
-      { host, port, reconnect: true },
-      {
-        onError: (error) => {
-          console.error("Hub client error:", error.message);
-        },
-        onQuestion: (question) => {
-          console.error(`[Question received from ${question.from.displayName}]`);
-        }
-      }
-    );
-    try {
-      await hubClient.connect();
-      if (options.team) {
-        await hubClient.join(options.team, `${options.team} Claude`);
-        console.error(`Auto-joined team: ${options.team}`);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      console.error(`Failed to connect to hub: ${errorMessage}`);
-      console.error("Make sure the hub server is running or use --auto-hub flag.");
-      process.exit(1);
-    }
-    await startMcpServer({ hubClient });
-  }
-);
 program.parse();
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map