@klitchevo/code-council 0.0.8 → 0.0.13

package/dist/index.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import {
+  SYSTEM_PROMPT,
+  buildUserMessage
+} from "./chunk-Y77R7523.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -14,8 +18,25 @@ var LLM_CONFIG = {
 var DEFAULT_MODELS = [
   "minimax/minimax-m2.1",
   "z-ai/glm-4.7",
-  "x-ai/grok-code-fast-1"
+  "moonshotai/kimi-k2-thinking",
+  "deepseek/deepseek-v3.2"
 ];
+var SESSION_LIMITS = {
+  /** Maximum number of concurrent sessions */
+  MAX_SESSIONS: 100,
+  /** Maximum messages per model in a session (context windowing) */
+  MAX_MESSAGES_PER_MODEL: 50,
+  /** Maximum message length in bytes (10KB) */
+  MAX_MESSAGE_LENGTH: 10 * 1024,
+  /** Session TTL in milliseconds (30 minutes) */
+  TTL_MS: 30 * 60 * 1e3,
+  /** Cleanup interval in milliseconds (5 minutes) */
+  CLEANUP_INTERVAL_MS: 5 * 60 * 1e3,
+  /** Rate limit: max requests per session per minute */
+  RATE_LIMIT_PER_MINUTE: 10,
+  /** Per-model timeout in milliseconds (30 seconds) */
+  MODEL_TIMEOUT_MS: 30 * 1e3
+};
 
 // src/config.ts
 function parseModels(envVar, defaults) {
@@ -26,17 +47,15 @@ function parseModels(envVar, defaults) {
     const filtered = envVar.filter((m) => m && m.trim().length > 0);
     return filtered.length > 0 ? filtered : defaults;
   }
-  if (typeof envVar === "string") {
-    try {
-      const parsed = JSON.parse(envVar);
-      if (Array.isArray(parsed)) {
-        const filtered = parsed.filter(
-          (m) => typeof m === "string" && m.trim().length > 0
-        );
-        return filtered.length > 0 ? filtered : defaults;
-      }
-    } catch {
+  try {
+    const parsed = JSON.parse(envVar);
+    if (Array.isArray(parsed)) {
+      const filtered = parsed.filter(
+        (m) => typeof m === "string" && m.trim().length > 0
+      );
+      return filtered.length > 0 ? filtered : defaults;
     }
+  } catch {
   }
   throw new Error(
     `Model configuration must be an array of strings, got: ${typeof envVar}. Example: ["anthropic/claude-sonnet-4.5", "openai/gpt-4o"]`
@@ -58,6 +77,76 @@ var PLAN_REVIEW_MODELS = parseModels(
   process.env.PLAN_REVIEW_MODELS,
   DEFAULT_MODELS
 );
+var DISCUSSION_MODELS = parseModels(
+  process.env.DISCUSSION_MODELS,
+  DEFAULT_MODELS
+);
+var TPS_AUDIT_MODELS = parseModels(
+  process.env.TPS_AUDIT_MODELS,
+  DEFAULT_MODELS
+);
+
+// src/errors.ts
+var AppError = class extends Error {
+  constructor(message, code, userMessage) {
+    super(message);
+    this.code = code;
+    this.userMessage = userMessage;
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var OpenRouterError = class extends AppError {
+  constructor(message, statusCode, retryable = false) {
+    super(
+      message,
+      "OPENROUTER_ERROR",
+      retryable ? "The AI service is temporarily unavailable. Please try again in a moment." : "Unable to complete the review. Please check your API key and try again."
+    );
+    this.statusCode = statusCode;
+    this.retryable = retryable;
+  }
+};
+var ValidationError = class extends AppError {
+  constructor(message, field) {
+    super(
+      message,
+      "VALIDATION_ERROR",
+      `Invalid input for ${field}: ${message}`
+    );
+    this.field = field;
+  }
+};
+function formatErrorMessage(error) {
+  if (error instanceof AppError) {
+    return error.userMessage || error.message;
+  }
+  if (error instanceof Error) {
+    const sanitized = error.message.replace(/sk-or-v1-[a-zA-Z0-9]+/g, "[REDACTED]").replace(/Bearer [a-zA-Z0-9-_]+/g, "Bearer [REDACTED]");
+    if (sanitized.includes("401") || sanitized.includes("Unauthorized")) {
+      return "API authentication failed. Please check your OPENROUTER_API_KEY environment variable.";
+    }
+    if (sanitized.includes("429") || sanitized.includes("rate limit")) {
+      return "Rate limit exceeded. Please wait a moment and try again.";
+    }
+    if (sanitized.includes("timeout") || sanitized.includes("ETIMEDOUT")) {
+      return "Request timed out. The AI service may be slow. Please try again.";
+    }
+    return sanitized;
+  }
+  return "An unexpected error occurred. Please try again.";
+}
+function formatError(error) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${formatErrorMessage(error)}`
+      }
+    ],
+    isError: true
+  };
+}
 
 // src/logger.ts
 var Logger = class {
@@ -117,61 +206,9 @@ var logger = new Logger();
 // src/review-client.ts
 import { OpenRouter } from "@openrouter/sdk";
 
-// src/errors.ts
-var AppError = class extends Error {
-  constructor(message, code, userMessage) {
-    super(message);
-    this.code = code;
-    this.userMessage = userMessage;
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-  }
-};
-var OpenRouterError = class extends AppError {
-  constructor(message, statusCode, retryable = false) {
-    super(
-      message,
-      "OPENROUTER_ERROR",
-      retryable ? "The AI service is temporarily unavailable. Please try again in a moment." : "Unable to complete the review. Please check your API key and try again."
-    );
-    this.statusCode = statusCode;
-    this.retryable = retryable;
-  }
-};
-function formatErrorMessage(error) {
-  if (error instanceof AppError) {
-    return error.userMessage || error.message;
-  }
-  if (error instanceof Error) {
-    const sanitized = error.message.replace(/sk-or-v1-[a-zA-Z0-9]+/g, "[REDACTED]").replace(/Bearer [a-zA-Z0-9-_]+/g, "Bearer [REDACTED]");
-    if (sanitized.includes("401") || sanitized.includes("Unauthorized")) {
-      return "API authentication failed. Please check your OPENROUTER_API_KEY environment variable.";
-    }
-    if (sanitized.includes("429") || sanitized.includes("rate limit")) {
-      return "Rate limit exceeded. Please wait a moment and try again.";
-    }
-    if (sanitized.includes("timeout") || sanitized.includes("ETIMEDOUT")) {
-      return "Request timed out. The AI service may be slow. Please try again.";
-    }
-    return sanitized;
-  }
-  return "An unexpected error occurred. Please try again.";
-}
-function formatError(error) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Error: ${formatErrorMessage(error)}`
-      }
-    ],
-    isError: true
-  };
-}
-
 // src/prompts/backend-review.ts
-var SYSTEM_PROMPT = `You are an expert backend developer and security specialist. Review backend code for security, performance, and architecture.`;
-function buildUserMessage(code, reviewType = "full", language, context) {
+var SYSTEM_PROMPT2 = `You are an expert backend developer and security specialist. Review backend code for security, performance, and architecture.`;
+function buildUserMessage2(code, reviewType = "full", language, context) {
   const focusArea = getFocusArea(reviewType);
   const languageContext = language ? `Language/Framework: ${language}
 ` : "";
@@ -198,7 +235,7 @@ function getFocusArea(reviewType) {
 }
 
 // src/prompts/code-review.ts
-var SYSTEM_PROMPT2 = `You are an expert code reviewer. Analyze the code for:
+var SYSTEM_PROMPT3 = `You are an expert code reviewer. Analyze the code for:
 - Code quality and best practices
 - Potential bugs and edge cases
 - Performance issues
@@ -206,7 +243,7 @@ var SYSTEM_PROMPT2 = `You are an expert code reviewer. Analyze the code for:
 - Maintainability concerns
 
 Provide specific, actionable feedback.`;
-function buildUserMessage2(code, context) {
+function buildUserMessage3(code, context) {
   if (context) {
     return `${context}
 
@@ -222,8 +259,8 @@ ${code}
 }
 
 // src/prompts/frontend-review.ts
-var SYSTEM_PROMPT3 = `You are an expert frontend developer and UX specialist. Review frontend code for best practices.`;
-function buildUserMessage3(code, reviewType = "full", framework, context) {
+var SYSTEM_PROMPT4 = `You are an expert frontend developer and UX specialist. Review frontend code for best practices.`;
+function buildUserMessage4(code, reviewType = "full", framework, context) {
   const focusArea = getFocusArea2(reviewType);
   const frameworkContext = framework ? `Framework: ${framework}
 ` : "";
@@ -250,8 +287,8 @@ function getFocusArea2(reviewType) {
 }
 
 // src/prompts/plan-review.ts
-var SYSTEM_PROMPT4 = `You are an expert software architect and project planner. Review implementation plans before code is written to catch issues early.`;
-function buildUserMessage4(plan, reviewType = "full", context) {
+var SYSTEM_PROMPT5 = `You are an expert software architect and project planner. Review implementation plans before code is written to catch issues early.`;
+function buildUserMessage5(plan, reviewType = "full", context) {
   const focusArea = getFocusArea3(reviewType);
   const additionalContext = context ? `${context}
 ` : "";
@@ -351,17 +388,17 @@ var ReviewClient = class {
    * @returns Array of review results from each model
    */
   async reviewCode(code, models, context) {
-    const userMessage = buildUserMessage2(code, context);
+    const userMessage = buildUserMessage3(code, context);
     return executeInParallel(
       models,
-      (model) => this.chat(model, SYSTEM_PROMPT2, userMessage)
+      (model) => this.chat(model, SYSTEM_PROMPT3, userMessage)
     );
   }
   /**
    * Review frontend code for accessibility, performance, and UX
    */
   async reviewFrontend(code, models, options) {
-    const userMessage = buildUserMessage3(
+    const userMessage = buildUserMessage4(
       code,
       options?.reviewType || "full",
       options?.framework,
@@ -369,14 +406,14 @@ var ReviewClient = class {
     );
     return executeInParallel(
       models,
-      (model) => this.chat(model, SYSTEM_PROMPT3, userMessage)
+      (model) => this.chat(model, SYSTEM_PROMPT4, userMessage)
     );
   }
   /**
    * Review backend code for security, performance, and architecture
    */
   async reviewBackend(code, models, options) {
-    const userMessage = buildUserMessage(
+    const userMessage = buildUserMessage2(
       code,
       options?.reviewType || "full",
       options?.language,
@@ -384,26 +421,602 @@ var ReviewClient = class {
     );
     return executeInParallel(
       models,
-      (model) => this.chat(model, SYSTEM_PROMPT, userMessage)
+      (model) => this.chat(model, SYSTEM_PROMPT2, userMessage)
     );
   }
   /**
    * Review implementation plans before code is written
    */
   async reviewPlan(plan, models, options) {
-    const userMessage = buildUserMessage4(
+    const userMessage = buildUserMessage5(
       plan,
       options?.reviewType || "full",
       options?.context
     );
     return executeInParallel(
       models,
-      (model) => this.chat(model, SYSTEM_PROMPT4, userMessage)
+      (model) => this.chat(model, SYSTEM_PROMPT5, userMessage)
     );
   }
+  /**
+   * Send a multi-turn chat request with full message history
+   * @param model - Model identifier
+   * @param messages - Full conversation history
+   * @param timeoutMs - Optional timeout in milliseconds
+   * @returns The model's response content
+   * @throws {OpenRouterError} If the API call fails or times out
+   */
+  async chatMultiTurn(model, messages, timeoutMs) {
+    const timeout = timeoutMs ?? SESSION_LIMITS.MODEL_TIMEOUT_MS;
+    try {
+      logger.debug("Sending multi-turn chat request", {
+        model,
+        messageCount: messages.length
+      });
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await this.client.chat.send({
+          model,
+          messages: messages.map((m) => ({
+            role: m.role,
+            content: m.content
+          })),
+          temperature: LLM_CONFIG.DEFAULT_TEMPERATURE,
+          maxTokens: LLM_CONFIG.DEFAULT_MAX_TOKENS
+        });
+        clearTimeout(timeoutId);
+        const content = response.choices?.[0]?.message?.content;
+        if (typeof content === "string") {
+          logger.debug("Received multi-turn response", {
+            model,
+            length: content.length
+          });
+          return content;
+        }
+        if (Array.isArray(content)) {
+          const text = content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+          logger.debug("Received array response", {
+            model,
+            length: text.length
+          });
+          return text;
+        }
+        throw new OpenRouterError("No response content from model", 500);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      if (error instanceof OpenRouterError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.error("Multi-turn chat request failed", error, { model });
+      if (message.includes("abort") || message.includes("timeout") || error instanceof Error && error.name === "AbortError") {
+        throw new OpenRouterError(
+          `Request timed out after ${timeout}ms`,
+          408,
+          true
+        );
+      }
+      const isRetryable = message.includes("429") || message.includes("rate limit");
+      throw new OpenRouterError(message, void 0, isRetryable);
+    }
+  }
+  /**
+   * Conduct a council discussion with multiple models
+   * Each model uses its own conversation history from the provided function
+   * @param models - Array of model identifiers
+   * @param getMessagesForModel - Function to get messages for each model
+   * @returns Array of results from each model
+   */
+  async discussWithCouncil(models, getMessagesForModel) {
+    return executeInParallel([...models], async (model) => {
+      const messages = getMessagesForModel(model);
+      return this.chatMultiTurn(model, messages);
+    });
+  }
+  /**
+   * Perform TPS (Toyota Production System) audit on aggregated codebase content
+   * Analyzes code for flow, waste, bottlenecks, and quality using TPS principles
+   *
+   * @param aggregatedContent - Aggregated file contents from repo scanner
+   * @param models - Array of model identifiers to use
+   * @param options - Optional configuration
+   * @returns Array of TPS analysis results from each model
+   */
+  async tpsAudit(aggregatedContent, models, options) {
+    const userMessage = buildUserMessage(aggregatedContent, {
+      focusAreas: options?.focusAreas,
+      repoName: options?.repoName
+    });
+    logger.debug("Starting TPS audit", {
+      contentLength: aggregatedContent.length,
+      modelCount: models.length,
+      focusAreas: options?.focusAreas
+    });
+    return executeInParallel(
+      models,
+      (model) => this.chat(model, SYSTEM_PROMPT, userMessage)
+    );
+  }
+};
+
+// src/session/in-memory-store.ts
+import { randomUUID } from "crypto";
+
+// src/session/types.ts
+var DISCUSSION_TYPES = [
+  "code_review",
+  "plan_review",
+  "general"
+];
+function toSessionId(id) {
+  return id;
+}
+
+// src/session/in-memory-store.ts
+var InMemorySessionStore = class {
+  sessions = {};
+  rateLimits = {};
+  cleanupInterval = null;
+  ttlMs;
+  maxSessions;
+  maxMessagesPerModel;
+  rateLimitPerMinute;
+  constructor(options) {
+    this.ttlMs = options?.ttlMs ?? SESSION_LIMITS.TTL_MS;
+    this.maxSessions = options?.maxSessions ?? SESSION_LIMITS.MAX_SESSIONS;
+    this.maxMessagesPerModel = options?.maxMessagesPerModel ?? SESSION_LIMITS.MAX_MESSAGES_PER_MODEL;
+    this.rateLimitPerMinute = options?.rateLimitPerMinute ?? SESSION_LIMITS.RATE_LIMIT_PER_MINUTE;
+    const cleanupIntervalMs = options?.cleanupIntervalMs ?? SESSION_LIMITS.CLEANUP_INTERVAL_MS;
+    this.startCleanupTimer(cleanupIntervalMs);
+  }
+  createSession(options) {
+    const sessionCount = Object.keys(this.sessions).length;
+    if (sessionCount >= this.maxSessions) {
+      this.evictOldestSession();
+    }
+    const sessionId = toSessionId(randomUUID());
+    const now = Date.now();
+    const modelConversations = {};
+    for (const model of options.models) {
+      modelConversations[model] = {
+        model,
+        messages: [
+          { role: "system", content: options.systemPrompt, timestamp: now },
+          {
+            role: "user",
+            content: options.initialUserMessage,
+            timestamp: now
+          }
+        ],
+        lastActive: now
+      };
+    }
+    const session = {
+      id: sessionId,
+      topic: options.topic,
+      discussionType: options.discussionType,
+      modelConversations,
+      createdAt: now,
+      lastActiveAt: now,
+      models: [...options.models]
+    };
+    this.sessions[sessionId] = session;
+    this.rateLimits[sessionId] = {
+      sessionId,
+      requestCount: 1,
+      // Count the initial creation
+      windowStart: now
+    };
+    logger.info("Created discussion session", {
+      sessionId,
+      topic: options.topic,
+      discussionType: options.discussionType,
+      modelCount: options.models.length
+    });
+    return session;
+  }
+  getSession(id) {
+    const session = this.sessions[id];
+    if (session) {
+      session.lastActiveAt = Date.now();
+    }
+    return session;
+  }
+  addUserMessage(id, message) {
+    const session = this.sessions[id];
+    if (!session) {
+      return false;
+    }
+    const now = Date.now();
+    session.lastActiveAt = now;
+    for (const model of session.models) {
+      const conversation = session.modelConversations[model];
+      if (conversation) {
+        if (conversation.messages.length >= this.maxMessagesPerModel) {
+          const systemMsg = conversation.messages[0];
+          if (systemMsg) {
+            conversation.messages = [
+              systemMsg,
+              ...conversation.messages.slice(-(this.maxMessagesPerModel - 2))
+            ];
+          }
+        }
+        conversation.messages.push({
+          role: "user",
+          content: message,
+          timestamp: now
+        });
+        conversation.lastActive = now;
+      }
+    }
+    return true;
+  }
+  addAssistantMessage(id, model, response) {
+    const session = this.sessions[id];
+    if (!session) {
+      return false;
+    }
+    const conversation = session.modelConversations[model];
+    if (!conversation) {
+      return false;
+    }
+    const now = Date.now();
+    conversation.messages.push({
+      role: "assistant",
+      content: response,
+      timestamp: now
+    });
+    conversation.lastActive = now;
+    session.lastActiveAt = now;
+    return true;
+  }
+  getModelMessages(id, model) {
+    const session = this.sessions[id];
+    if (!session) {
+      return void 0;
+    }
+    session.lastActiveAt = Date.now();
+    return session.modelConversations[model]?.messages;
+  }
+  deleteSession(id) {
+    const existed = id in this.sessions;
+    if (existed) {
+      delete this.sessions[id];
+      delete this.rateLimits[id];
+      logger.debug("Deleted session", { sessionId: id });
+    }
+    return existed;
+  }
+  getSessionCount() {
+    return Object.keys(this.sessions).length;
+  }
+  checkRateLimit(id) {
+    const now = Date.now();
+    const windowMs = 60 * 1e3;
+    const state = this.rateLimits[id];
+    if (!state) {
+      return {
+        allowed: false,
+        remainingRequests: 0,
+        resetInMs: 0
+      };
+    }
+    if (now - state.windowStart >= windowMs) {
+      state.requestCount = 0;
+      state.windowStart = now;
+    }
+    const remaining = this.rateLimitPerMinute - state.requestCount;
+    const resetInMs = windowMs - (now - state.windowStart);
+    if (state.requestCount >= this.rateLimitPerMinute) {
+      return {
+        allowed: false,
+        remainingRequests: 0,
+        resetInMs
+      };
+    }
+    state.requestCount++;
+    return {
+      allowed: true,
+      remainingRequests: remaining - 1,
+      resetInMs
+    };
+  }
+  shutdown() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    const sessionCount = Object.keys(this.sessions).length;
+    this.sessions = {};
+    this.rateLimits = {};
+    logger.info("Session store shutdown", { clearedSessions: sessionCount });
+  }
+  /**
+   * Start the periodic cleanup timer
+   */
+  startCleanupTimer(intervalMs) {
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupExpiredSessions();
+    }, intervalMs);
+    this.cleanupInterval.unref();
+  }
+  /**
+   * Remove sessions that have exceeded the TTL
+   */
+  cleanupExpiredSessions() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const sessionId of Object.keys(this.sessions)) {
+      const session = this.sessions[sessionId];
+      if (session && now - session.lastActiveAt > this.ttlMs) {
+        delete this.sessions[sessionId];
+        delete this.rateLimits[sessionId];
+        cleaned++;
+      }
+    }
+    if (cleaned > 0) {
+      logger.info("Cleaned up expired sessions", { count: cleaned });
+    }
+  }
+  /**
+   * Evict the oldest session when at capacity (LRU eviction)
+   */
+  evictOldestSession() {
+    let oldestId = null;
+    let oldestTime = Number.POSITIVE_INFINITY;
+    for (const sessionId of Object.keys(this.sessions)) {
+      const session = this.sessions[sessionId];
+      if (session && session.lastActiveAt < oldestTime) {
+        oldestTime = session.lastActiveAt;
+        oldestId = sessionId;
+      }
+    }
+    if (oldestId) {
+      delete this.sessions[oldestId];
+      delete this.rateLimits[oldestId];
+      logger.warn("Evicted oldest session due to capacity", {
+        sessionId: oldestId
+      });
+    }
+  }
+};
+
+// src/tools/conversation-factory.ts
+function formatDiscussionResults(results, sessionId, isNewSession, topic) {
+  const header = isNewSession ? `# Council Discussion Started
+
+**Topic:** ${topic}
+**Session ID:** \`${sessionId}\`
+
+_Use this session_id in subsequent calls to continue the discussion._
+
+---
+
+` : `# Council Discussion Continued
+
+**Session ID:** \`${sessionId}\`
+
+---
+
+`;
+  const responses = results.map((r) => {
+    const modelName = r.model.split("/").pop() || r.model;
+    if (r.error) {
+      return `## ${modelName}
+
+**Error:** ${r.error}`;
+    }
+    return `## ${modelName}
+
+${r.review}`;
+  }).join("\n\n---\n\n");
+  const footer = `
+
+---
+
+**Session ID:** \`${sessionId}\` _(include in your next message to continue)_`;
+  return header + responses + footer;
+}
+function createConversationTool(server2, config, sessionStore2) {
+  server2.registerTool(
+    config.name,
+    {
+      description: config.description,
+      inputSchema: config.inputSchema
+    },
+    async (input) => {
+      try {
+        logger.debug(`Starting ${config.name}`, {
+          inputKeys: Object.keys(input)
+        });
+        const { results, models, sessionId, isNewSession, topic } = await config.handler(input, sessionStore2);
+        logger.info(`Completed ${config.name}`, {
+          sessionId,
+          isNewSession,
+          modelCount: models.length,
+          successCount: results.filter((r) => !r.error).length,
+          errorCount: results.filter((r) => r.error).length
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatDiscussionResults(
+                results,
+                sessionId,
+                isNewSession,
+                topic
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        logger.error(
+          `Error in ${config.name}`,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        return formatError(error);
+      }
+    }
+  );
+}
+
+// src/tools/discuss-council.ts
+import { z } from "zod";
+
+// src/prompts/discussion.ts
+var DISCUSSION_SYSTEM_PROMPTS = {
+  code_review: `You are a senior software engineer participating in a code review council discussion.
+
+Your role:
+- Provide thoughtful, constructive feedback on code and technical decisions
+- Build on your previous responses in this conversation
+- Consider alternative approaches and trade-offs
+- Be specific with examples and suggestions
+- Respectfully challenge ideas while remaining collaborative
+
+Focus on code quality, maintainability, performance, security, and best practices.
+Keep responses focused and actionable.`,
+  plan_review: `You are a senior software architect participating in a planning council discussion.
+
+Your role:
+- Evaluate implementation plans, architecture decisions, and technical strategies
+- Build on your previous responses in this conversation
+- Consider feasibility, risks, scalability, and maintainability
+- Suggest alternatives and improvements
+- Think about edge cases and potential issues
+
+Focus on practical implementation concerns and long-term implications.
+Keep responses focused and actionable.`,
+  general: `You are a knowledgeable advisor participating in a council discussion.
+
+Your role:
+- Provide thoughtful, well-reasoned perspectives on the topic
+- Build on your previous responses in this conversation
+- Consider multiple viewpoints and trade-offs
+- Support your points with examples and reasoning
+- Be open to exploring different approaches
+
+Keep responses focused and constructive.`
+};
+function getSystemPrompt(discussionType) {
+  return DISCUSSION_SYSTEM_PROMPTS[discussionType];
+}
+function buildInitialMessage(message, discussionType, context) {
+  const typeLabel = {
+    code_review: "Code Review Discussion",
+    plan_review: "Plan Review Discussion",
+    general: "Discussion"
+  };
+  let content = `**${typeLabel[discussionType]}**
+
+${message}`;
+  if (context) {
+    content += `
+
+**Additional Context:**
+${context}`;
+  }
+  return content;
+}
+
+// src/tools/discuss-council.ts
+var discussCouncilSchema = {
+  message: z.string().min(1, "Message cannot be empty").max(
+    SESSION_LIMITS.MAX_MESSAGE_LENGTH,
+    `Message exceeds maximum length of ${SESSION_LIMITS.MAX_MESSAGE_LENGTH} characters`
+  ).describe("Your message or question for the council"),
+  session_id: z.string().uuid("Invalid session ID format").optional().describe(
+    "Session ID to continue an existing discussion. Omit to start a new discussion."
+  ),
+  discussion_type: z.enum(DISCUSSION_TYPES).optional().describe(
+    "Type of discussion (only used when starting new session). 'code_review' for code-related discussions, 'plan_review' for architecture/planning, 'general' for other topics. Default: general"
+  ),
+  context: z.string().max(
+    SESSION_LIMITS.MAX_MESSAGE_LENGTH,
+    `Context exceeds maximum length of ${SESSION_LIMITS.MAX_MESSAGE_LENGTH} characters`
+  ).optional().describe(
+    "Additional context for new discussions (code snippets, plan details, etc.)"
+  )
 };
+async function handleDiscussCouncil(client2, input, sessionStore2) {
+  const { message, session_id, discussion_type, context } = input;
+  let sessionId;
+  let isNewSession = false;
+  if (session_id) {
+    sessionId = toSessionId(session_id);
+    const existingSession = sessionStore2.getSession(sessionId);
+    if (!existingSession) {
+      throw new ValidationError(
+        `Session not found: ${session_id}. It may have expired or been deleted.`,
+        "session_id"
+      );
+    }
+    const rateLimitResult = sessionStore2.checkRateLimit(sessionId);
+    if (!rateLimitResult.allowed) {
+      throw new ValidationError(
+        `Rate limit exceeded. Please wait ${Math.ceil(rateLimitResult.resetInMs / 1e3)} seconds before sending another message.`,
+        "session_id"
+      );
+    }
+    sessionStore2.addUserMessage(sessionId, message);
+    logger.info("Continuing council discussion", {
+      sessionId,
+      modelCount: existingSession.models.length
+    });
+  } else {
+    isNewSession = true;
+    const type = discussion_type || "general";
+    const systemPrompt = getSystemPrompt(type);
+    const initialMessage = buildInitialMessage(message, type, context);
+    const topic = message.length > 100 ? `${message.slice(0, 97)}...` : message;
+    const session2 = sessionStore2.createSession({
+      topic,
+      discussionType: type,
+      models: DISCUSSION_MODELS,
+      systemPrompt,
+      initialUserMessage: initialMessage
+    });
+    sessionId = session2.id;
+    logger.info("Started new council discussion", {
+      sessionId,
+      discussionType: type,
+      modelCount: DISCUSSION_MODELS.length
+    });
+  }
+  const session = sessionStore2.getSession(sessionId);
+  if (!session) {
+    throw new ValidationError("Session was unexpectedly deleted", "session_id");
+  }
+  const currentSessionId = sessionId;
+  const results = await client2.discussWithCouncil(session.models, (model) => {
+    const messages = sessionStore2.getModelMessages(currentSessionId, model);
+    if (!messages) {
+      throw new Error(`No messages found for model ${model}`);
+    }
+    return messages;
+  });
+  for (const result of results) {
+    if (!result.error && result.review) {
+      sessionStore2.addAssistantMessage(sessionId, result.model, result.review);
+    }
+  }
+  return {
+    results,
+    models: session.models,
+    sessionId,
+    isNewSession,
+    topic: session.topic
+  };
+}
 
 // src/tools/factory.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 function formatResults(results) {
   return results.map((r) => {
     if (r.error) {
@@ -416,6 +1029,39 @@ function formatResults(results) {
 ${r.review}`;
   }).join("\n\n---\n\n");
 }
+function formatResultsAsHtml(results, templatePath, data = {}) {
+  try {
+    let template = readFileSync(templatePath, "utf-8");
+    const modelPerspectives = results.map((r) => ({
+      model: r.model,
+      content: r.error ? `Error: ${r.error}` : r.review,
+      hasError: !!r.error
+    }));
+    const reportData = {
+      analysis: data.analysis || null,
+      repoName: data.repoName || "Unknown Repository",
+      modelPerspectives,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    template = template.replace(
+      "{{REPORT_DATA}}",
+      JSON.stringify(reportData, null, 2)
+    );
+    return template;
+  } catch (error) {
+    logger.error("Failed to generate HTML report", error);
+    return formatResults(results);
+  }
+}
+function getTemplatesDir() {
+  try {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = dirname(__filename2);
+    return join(__dirname2, "..", "..", "templates");
+  } catch {
+    return join(process.cwd(), "templates");
+  }
+}
 function createReviewTool(server2, config) {
   server2.registerTool(
     config.name,
@@ -485,12 +1131,12 @@ To customize models, set environment variables in your MCP config:
 }
 
 // src/tools/review-backend.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var backendReviewSchema = {
-  code: z.string().describe("The backend code to review"),
-  language: z.string().optional().describe("Programming language/framework (e.g., node, python, go, rust)"),
-  review_type: z.enum(["security", "performance", "architecture", "full"]).optional().describe("Type of review to perform (default: full)"),
-  context: z.string().optional().describe("Additional context")
+  code: z2.string().describe("The backend code to review"),
+  language: z2.string().optional().describe("Programming language/framework (e.g., node, python, go, rust)"),
+  review_type: z2.enum(["security", "performance", "architecture", "full"]).optional().describe("Type of review to perform (default: full)"),
+  context: z2.string().optional().describe("Additional context")
 };
 async function handleBackendReview(client2, input) {
   const { code, language, review_type, context } = input;
@@ -513,11 +1159,11 @@ async function handleBackendReview(client2, input) {
 }
 
 // src/tools/review-code.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var codeReviewSchema = {
-  code: z2.string().describe("The code to review"),
-  language: z2.string().optional().describe("Programming language of the code"),
-  context: z2.string().optional().describe("Additional context about the code")
+  code: z3.string().describe("The code to review"),
+  language: z3.string().optional().describe("Programming language of the code"),
+  context: z3.string().optional().describe("Additional context about the code")
 };
 async function handleCodeReview(client2, input) {
   const { code, language, context } = input;
@@ -541,12 +1187,12 @@ ${context}` : ""}` : context;
 }
 
 // src/tools/review-frontend.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var frontendReviewSchema = {
-  code: z3.string().describe("The frontend code to review"),
-  framework: z3.string().optional().describe("Frontend framework (e.g., react, vue, svelte)"),
-  review_type: z3.enum(["accessibility", "performance", "ux", "full"]).optional().describe("Type of review to perform (default: full)"),
-  context: z3.string().optional().describe("Additional context")
+  code: z4.string().describe("The frontend code to review"),
+  framework: z4.string().optional().describe("Frontend framework (e.g., react, vue, svelte)"),
+  review_type: z4.enum(["accessibility", "performance", "ux", "full"]).optional().describe("Type of review to perform (default: full)"),
+  context: z4.string().optional().describe("Additional context")
 };
 async function handleFrontendReview(client2, input) {
   const { code, framework, review_type, context } = input;
@@ -570,13 +1216,13 @@ async function handleFrontendReview(client2, input) {
 
 // src/tools/review-git.ts
 import { execSync } from "child_process";
-import { z as z4 } from "zod";
-var gitReviewSchemaObj = z4.object({
-  review_type: z4.enum(["staged", "unstaged", "diff", "commit"]).optional().describe(
+import { z as z5 } from "zod";
+var gitReviewSchemaObj = z5.object({
+  review_type: z5.enum(["staged", "unstaged", "diff", "commit"]).optional().describe(
     "Type of changes to review: 'staged' (git diff --cached), 'unstaged' (git diff), 'diff' (git diff main..HEAD), 'commit' (specific commit). Default: staged"
   ),
-  commit_hash: z4.string().optional().describe("Commit hash to review (only used when review_type is 'commit')"),
-  context: z4.string().optional().describe("Additional context about the changes")
+  commit_hash: z5.string().optional().describe("Commit hash to review (only used when review_type is 'commit')"),
+  context: z5.string().optional().describe("Additional context about the changes")
 });
 var gitReviewSchema = gitReviewSchemaObj.shape;
 function getGitDiff(reviewType = "staged", commitHash) {
@@ -637,11 +1283,11 @@ async function handleGitReview(client2, models, input) {
 }
 
 // src/tools/review-plan.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var planReviewSchema = {
-  plan: z5.string().describe("The implementation plan to review"),
-  review_type: z5.enum(["feasibility", "completeness", "risks", "timeline", "full"]).optional().describe("Type of review to perform (default: full)"),
-  context: z5.string().optional().describe("Additional context about the project or constraints")
+  plan: z6.string().describe("The implementation plan to review"),
+  review_type: z6.enum(["feasibility", "completeness", "risks", "timeline", "full"]).optional().describe("Type of review to perform (default: full)"),
+  context: z6.string().optional().describe("Additional context about the project or constraints")
 };
 async function handlePlanReview(client2, input) {
   const { plan, review_type, context } = input;
@@ -661,6 +1307,598 @@ async function handlePlanReview(client2, input) {
   };
 }
 
+// src/tools/tps-audit.ts
+import { join as join4 } from "path";
+import { z as z7 } from "zod";
+
+// src/utils/repo-scanner.ts
+import { readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { extname, join as join3, relative as relative2 } from "path";
+import ignore from "ignore";
+
+// src/utils/git-operations.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync, lstatSync, realpathSync } from "fs";
+import { dirname as dirname2, join as join2, normalize, relative, resolve } from "path";
+var MAX_TRAVERSAL_DEPTH = 20;
+function findGitRoot(startPath) {
+  let currentPath = resolve(startPath);
+  let depth = 0;
+  while (depth < MAX_TRAVERSAL_DEPTH) {
+    const gitPath = join2(currentPath, ".git");
+    if (existsSync(gitPath)) {
+      logger.debug("Found git root", { path: currentPath, depth });
+      return currentPath;
+    }
+    const parentPath = dirname2(currentPath);
+    if (parentPath === currentPath) {
+      throw new Error(
+        `Not in a git repository. Searched from ${startPath} to filesystem root.`
+      );
+    }
+    currentPath = parentPath;
+    depth++;
+  }
+  throw new Error(
+    `Max directory traversal depth (${MAX_TRAVERSAL_DEPTH}) exceeded while searching for git root.`
+  );
+}
+function isInsideRepo(filePath, repoRoot) {
+  try {
+    const normalizedRepo = normalize(resolve(repoRoot));
+    const normalizedFile = normalize(resolve(filePath));
+    const relativePath = relative(normalizedRepo, normalizedFile);
+    if (relativePath.startsWith("..") || resolve(relativePath) === relativePath) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveAndValidatePath(filePath, repoRoot) {
+  try {
+    const absolutePath = resolve(repoRoot, filePath);
+    const stats = lstatSync(absolutePath);
+    if (stats.isSymbolicLink()) {
+      const realPath = realpathSync(absolutePath);
+      if (!isInsideRepo(realPath, repoRoot)) {
+        logger.warn("Symlink target outside repository", {
+          symlink: filePath,
+          target: realPath,
+          repo: repoRoot
+        });
+        return null;
+      }
+      return realPath;
+    }
+    if (!isInsideRepo(absolutePath, repoRoot)) {
+      return null;
+    }
+    return absolutePath;
+  } catch (error) {
+    logger.debug("Path resolution failed", { filePath, error });
+    return null;
+  }
+}
+
+// src/utils/repo-scanner.ts
+var SENSITIVE_FILE_PATTERNS = [
+  ".env",
+  ".env.*",
+  "*.pem",
+  "*.key",
+  "*.p12",
+  "*.pfx",
+  "*.crt",
+  "*credentials*",
+  "*secret*",
+  "id_rsa*",
+  "id_ed25519*",
+  "id_dsa*",
+  "id_ecdsa*",
+  ".npmrc",
+  ".pypirc",
+  "kubeconfig",
+  ".kube/config",
+  ".docker/config.json",
+  "*password*",
+  "*token*",
+  "auth.json",
+  ".netrc",
+  ".git-credentials",
+  "*.keystore",
+  "*.jks",
+  "service-account*.json",
+  "gcloud*.json"
+];
+var SECRET_CONTENT_PATTERNS = [
+  /AKIA[0-9A-Z]{16}/g,
+  // AWS Access Key ID
+  /-----BEGIN\s+(RSA |DSA |EC |OPENSSH )?PRIVATE KEY-----/g,
+  // Private keys
+  /-----BEGIN\s+PGP PRIVATE KEY BLOCK-----/g,
+  // PGP private key
+  /ghp_[a-zA-Z0-9]{36}/g,
+  // GitHub Personal Access Token
+  /gho_[a-zA-Z0-9]{36}/g,
+  // GitHub OAuth Token
+  /ghs_[a-zA-Z0-9]{36}/g,
+  // GitHub Server Token
+  /ghu_[a-zA-Z0-9]{36}/g,
+  // GitHub User Token
+  /sk-[a-zA-Z0-9]{48}/g,
+  // OpenAI API Key
+  /sk-proj-[a-zA-Z0-9]{48}/g,
+  // OpenAI Project Key
+  /xox[baprs]-[0-9]{10,13}-[0-9]{10,13}-[a-zA-Z0-9]{24}/g,
+  // Slack tokens
+  /eyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*/g,
+  // JWT tokens
+  /AIza[0-9A-Za-z_-]{35}/g,
+  // Google API Key
+  /[0-9a-f]{32}-us[0-9]+/g,
+  // Mailchimp API Key
+  /SG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}/g,
+  // SendGrid API Key
+  /sq0[a-z]{3}-[0-9A-Za-z_-]{22}/g
+  // Square tokens
+];
+var DEFAULT_FILE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".scala",
+  ".rb",
+  ".php",
+  ".cs",
+  ".cpp",
+  ".c",
+  ".h",
+  ".hpp",
+  ".swift",
+  ".vue",
+  ".svelte",
+  ".astro"
+];
+var EXCLUDED_DIRS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  "venv",
+  ".venv",
+  "env",
+  ".env",
+  "vendor",
+  "target",
+  ".idea",
+  ".vscode",
+  "coverage",
+  ".nyc_output"
+];
+var HARD_LIMITS = {
+  MAX_FILES: 100,
+  MAX_FILE_SIZE: 100 * 1024,
+  // 100KB per file
+  MAX_TOTAL_SIZE: 1024 * 1024
+  // 1MB total
+};
+var DEFAULT_OPTIONS = {
+  maxFiles: 50,
+  maxFileSize: 50 * 1024,
+  // 50KB
+  maxTotalSize: 500 * 1024,
+  // 500KB
+  fileTypes: DEFAULT_FILE_EXTENSIONS,
+  skipSensitive: true,
+  detectSecrets: true
+};
+function isSensitiveFile(filename) {
+  const lowerName = filename.toLowerCase();
+  for (const pattern of SENSITIVE_FILE_PATTERNS) {
+    if (pattern.includes("*")) {
+      const regex = new RegExp(
+        "^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$",
+        "i"
+      );
+      if (regex.test(lowerName)) {
+        return true;
+      }
+    } else if (lowerName === pattern.toLowerCase() || lowerName.endsWith(`/${pattern.toLowerCase()}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectEmbeddedSecrets(content) {
+  const detected = [];
+  const secretTypes = [
+    { pattern: SECRET_CONTENT_PATTERNS[0], name: "AWS Access Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[1], name: "Private Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[2], name: "PGP Private Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[3], name: "GitHub PAT" },
+    { pattern: SECRET_CONTENT_PATTERNS[4], name: "GitHub OAuth Token" },
+    { pattern: SECRET_CONTENT_PATTERNS[5], name: "GitHub Server Token" },
+    { pattern: SECRET_CONTENT_PATTERNS[6], name: "GitHub User Token" },
+    { pattern: SECRET_CONTENT_PATTERNS[7], name: "OpenAI API Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[8], name: "OpenAI Project Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[9], name: "Slack Token" },
+    { pattern: SECRET_CONTENT_PATTERNS[10], name: "JWT Token" },
+    { pattern: SECRET_CONTENT_PATTERNS[11], name: "Google API Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[12], name: "Mailchimp API Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[13], name: "SendGrid API Key" },
+    { pattern: SECRET_CONTENT_PATTERNS[14], name: "Square Token" }
+  ];
+  for (const { pattern, name } of secretTypes) {
+    if (!pattern) continue;
+    pattern.lastIndex = 0;
+    if (pattern.test(content)) {
+      detected.push(name);
+    }
+  }
+  return detected;
+}
+function isBinaryContent(content) {
+  for (let i = 0; i < Math.min(content.length, 8e3); i++) {
+    if (content[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function estimateTokens(content) {
+  return Math.ceil(content.length / 4);
+}
+async function scanRepository(startPath, options = {}) {
+  const opts = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+    maxFiles: Math.min(
+      options.maxFiles ?? DEFAULT_OPTIONS.maxFiles,
+      HARD_LIMITS.MAX_FILES
+    ),
+    maxFileSize: Math.min(
+      options.maxFileSize ?? DEFAULT_OPTIONS.maxFileSize,
+      HARD_LIMITS.MAX_FILE_SIZE
+    ),
+    maxTotalSize: Math.min(
+      options.maxTotalSize ?? DEFAULT_OPTIONS.maxTotalSize,
+      HARD_LIMITS.MAX_TOTAL_SIZE
+    )
+  };
+  const repoRoot = findGitRoot(startPath);
+  logger.info("Scanning repository", { repoRoot, options: opts });
+  const ig = ignore();
+  try {
+    const gitignorePath = join3(repoRoot, ".gitignore");
+    const gitignoreContent = readFileSync2(gitignorePath, "utf-8");
+    ig.add(gitignoreContent);
+  } catch {
+  }
+  ig.add(EXCLUDED_DIRS);
+  const files = [];
+  const skipped = [];
+  const warnings = [];
+  let totalSize = 0;
+  let totalFilesFound = 0;
+  function scanDir(dirPath, depth = 0) {
+    if (depth > 20) {
+      return;
+    }
+    if (files.length >= opts.maxFiles) {
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync(dirPath);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= opts.maxFiles) {
+        break;
+      }
+      const fullPath = join3(dirPath, entry);
+      const relativePath = relative2(repoRoot, fullPath);
+      if (ig.ignores(relativePath)) {
+        continue;
+      }
+      const validPath = resolveAndValidatePath(fullPath, repoRoot);
+      if (!validPath) {
+        skipped.push({
+          path: relativePath,
+          reason: "Path outside repository or invalid symlink"
+        });
+        continue;
+      }
+      let stats2;
+      try {
+        stats2 = statSync(validPath);
+      } catch {
+        continue;
+      }
+      if (stats2.isDirectory()) {
+        scanDir(fullPath, depth + 1);
+      } else if (stats2.isFile()) {
+        totalFilesFound++;
+        const ext = extname(entry).toLowerCase();
+        if (!opts.fileTypes.includes(ext)) {
+          continue;
+        }
+        if (opts.skipSensitive && isSensitiveFile(entry)) {
+          skipped.push({
+            path: relativePath,
+            reason: "Potentially sensitive file"
+          });
+          warnings.push(`Skipped sensitive file: ${relativePath}`);
+          continue;
+        }
+        if (stats2.size > opts.maxFileSize) {
+          skipped.push({
+            path: relativePath,
+            reason: `File too large (${stats2.size} bytes)`
+          });
+          continue;
+        }
+        if (totalSize + stats2.size > opts.maxTotalSize) {
+          skipped.push({
+            path: relativePath,
+            reason: "Total size limit reached"
+          });
+          continue;
+        }
+        let content;
+        try {
+          const buffer = readFileSync2(validPath);
+          if (isBinaryContent(buffer)) {
+            skipped.push({ path: relativePath, reason: "Binary file" });
+            continue;
+          }
+          content = buffer.toString("utf-8");
+        } catch {
+          skipped.push({ path: relativePath, reason: "Could not read file" });
+          continue;
+        }
+        if (opts.detectSecrets) {
+          const secrets = detectEmbeddedSecrets(content);
+          if (secrets.length > 0) {
+            skipped.push({
+              path: relativePath,
+              reason: `Contains potential secrets: ${secrets.join(", ")}`
+            });
+            warnings.push(
+              `Skipped file with potential secrets: ${relativePath} (${secrets.join(", ")})`
+            );
+            continue;
+          }
+        }
+        files.push({ path: relativePath, content });
+        totalSize += stats2.size;
+      }
+    }
+  }
+  scanDir(repoRoot);
+  const stats = {
+    totalFilesFound,
+    totalFilesIncluded: files.length,
+    totalSize,
+    tokenEstimate: files.reduce((sum, f) => sum + estimateTokens(f.content), 0)
+  };
+  logger.info("Repository scan complete", {
+    filesIncluded: files.length,
+    filesSkipped: skipped.length,
+    totalSize,
+    tokenEstimate: stats.tokenEstimate,
+    warnings: warnings.length
+  });
+  return {
+    files,
+    skipped,
+    warnings,
+    stats,
+    repoRoot
+  };
+}
+function aggregateFiles(files) {
+  return files.map(
+    (f) => `=== FILE: ${f.path} ===
+${f.content}
+=== END FILE: ${f.path} ===`
+  ).join("\n\n");
+}
+
+// src/tools/tps-audit.ts
+var tpsAuditSchemaObj = z7.object({
+  path: z7.string().optional().describe(
+    "Path to repo root (auto-detects current directory if not provided)"
+  ),
+  focus_areas: z7.array(z7.string()).optional().describe("Specific areas to focus on (e.g., 'performance', 'security')"),
+  max_files: z7.number().max(100).optional().describe("Maximum files to analyze (default: 50, max: 100)"),
+  file_types: z7.array(z7.string()).optional().describe("File extensions to include (e.g., ['.ts', '.js'])"),
+  include_sensitive: z7.boolean().optional().describe(
+    "Include potentially sensitive files (default: false, use with caution)"
+  ),
+  output_format: z7.enum(["html", "markdown", "json"]).optional().describe("Output format (default: html)")
+});
+var tpsAuditSchema = tpsAuditSchemaObj.shape;
+async function handleTpsAudit(client2, models, input) {
+  const startPath = input.path || process.cwd();
+  const outputFormat = input.output_format || "html";
+  logger.info("Starting TPS audit", {
+    startPath,
+    maxFiles: input.max_files,
+    focusAreas: input.focus_areas,
+    outputFormat,
+    modelCount: models.length
+  });
+  const scanResult = await scanRepository(startPath, {
+    maxFiles: input.max_files,
+    fileTypes: input.file_types,
+    skipSensitive: !input.include_sensitive,
+    detectSecrets: !input.include_sensitive
+  });
+  if (scanResult.files.length === 0) {
+    logger.warn("No files found to analyze", {
+      totalFilesFound: scanResult.stats.totalFilesFound,
+      skipped: scanResult.skipped.length
+    });
+    return {
+      results: [
+        {
+          model: "system",
+          review: "No files found to analyze. Check that the repository contains supported file types and that files are not excluded by .gitignore or security filters."
+        }
+      ],
+      models: ["system"],
+      scanResult,
+      analysis: null,
+      outputFormat
+    };
+  }
+  if (scanResult.warnings.length > 0) {
+    logger.warn("Security warnings during scan", {
+      warnings: scanResult.warnings
+    });
+  }
+  const aggregatedContent = aggregateFiles(scanResult.files);
+  logger.info("Repository scanned", {
+    filesIncluded: scanResult.files.length,
+    totalSize: scanResult.stats.totalSize,
+    tokenEstimate: scanResult.stats.tokenEstimate
+  });
+  if (scanResult.stats.tokenEstimate > 1e5) {
+    logger.warn("Large token count", {
+      estimate: scanResult.stats.tokenEstimate
+    });
+  }
+  const results = await client2.tpsAudit(aggregatedContent, models, {
+    focusAreas: input.focus_areas,
+    repoName: scanResult.repoRoot.split("/").pop()
+  });
+  let analysis = null;
+  for (const result of results) {
+    if (!result.error && result.review) {
+      const { parseTpsAnalysis } = await import("./tps-audit-GNK4VIKA.js");
+      analysis = parseTpsAnalysis(result.review);
+      if (analysis) break;
+    }
+  }
+  return {
+    results,
+    models,
+    scanResult,
+    analysis,
+    outputFormat
+  };
+}
+function formatTpsAuditResults(auditResult) {
+  const { results, scanResult, analysis, outputFormat } = auditResult;
+  switch (outputFormat) {
+    case "html": {
+      const templatePath = join4(getTemplatesDir(), "tps-report.html");
+      return formatResultsAsHtml(results, templatePath, {
+        analysis,
+        repoName: scanResult.repoRoot.split("/").pop()
+      });
+    }
+    case "json": {
+      return JSON.stringify(
+        {
+          analysis,
+          scanStats: scanResult.stats,
+          warnings: scanResult.warnings,
+          skipped: scanResult.skipped,
+          modelResponses: results.map((r) => ({
+            model: r.model,
+            hasError: !!r.error,
+            content: r.error || r.review
+          }))
+        },
+        null,
+        2
+      );
+    }
+    case "markdown":
+    default: {
+      const parts = [];
+      parts.push("# TPS Audit Report\n");
+      parts.push(`**Repository:** ${scanResult.repoRoot}
+`);
+      parts.push(`**Files Analyzed:** ${scanResult.files.length}
+`);
+      parts.push(`**Token Estimate:** ~${scanResult.stats.tokenEstimate}
+`);
+      if (scanResult.warnings.length > 0) {
+        parts.push("\n## Warnings\n");
+        for (const w of scanResult.warnings) {
+          parts.push(`- ${w}
+`);
+        }
+      }
+      if (analysis) {
+        parts.push("\n## Scores\n");
+        parts.push(`- **Overall:** ${analysis.scores.overall}/100
+`);
+        parts.push(`- **Flow:** ${analysis.scores.flow}/100
+`);
+        parts.push(`- **Waste Efficiency:** ${analysis.scores.waste}/100
+`);
+        parts.push(`- **Quality:** ${analysis.scores.quality}/100
+`);
+        parts.push("\n## Summary\n");
+        parts.push("\n### Strengths\n");
+        for (const s of analysis.summary.strengths) {
+          parts.push(`- ${s}
+`);
+        }
+        parts.push("\n### Concerns\n");
+        for (const c of analysis.summary.concerns) {
+          parts.push(`- ${c}
+`);
+        }
+        parts.push("\n### Quick Wins\n");
+        for (const q of analysis.summary.quickWins) {
+          parts.push(`- ${q}
+`);
+        }
+      }
+      parts.push("\n## Model Perspectives\n");
+      results.forEach((r) => {
+        if (r.error) {
+          parts.push(`
+### ${r.model}
+
+**Error:** ${r.error}
+`);
+        } else {
+          parts.push(`
+### ${r.model}
+
+${r.review}
+`);
+        }
+        parts.push("\n---\n");
+      });
+      return parts.join("");
+    }
+  }
+}
+
 // src/index.ts
 var OPENROUTER_API_KEY = process.env.OPENROUTER_API_KEY;
 if (!OPENROUTER_API_KEY) {
@@ -674,6 +1912,7 @@ if (!OPENROUTER_API_KEY) {
   process.exit(1);
 }
 var client = new ReviewClient(OPENROUTER_API_KEY);
+var sessionStore = new InMemorySessionStore();
 var server = new McpServer({
   name: "code-council",
   version: "1.0.0"
@@ -708,6 +1947,42 @@ createReviewTool(server, {
   inputSchema: gitReviewSchema,
   handler: (input) => handleGitReview(client, CODE_REVIEW_MODELS, input)
 });
+server.registerTool(
+  "tps_audit",
+  {
+    description: "Toyota Production System audit - analyze a codebase for flow, waste, bottlenecks, and quality. Scans the repository, identifies entry points, maps data flow, and provides actionable recommendations. Outputs interactive HTML report by default, or markdown/JSON.",
+    inputSchema: tpsAuditSchema
+  },
+  async (input) => {
+    try {
+      logger.debug("Starting tps_audit", {
+        inputKeys: Object.keys(input)
+      });
+      const result = await handleTpsAudit(client, TPS_AUDIT_MODELS, input);
+      const formattedOutput = formatTpsAuditResults(result);
+      logger.info("Completed tps_audit", {
+        modelCount: result.models.length,
+        filesScanned: result.scanResult.files.length,
+        outputFormat: result.outputFormat,
+        hasAnalysis: !!result.analysis
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: formattedOutput
+          }
+        ]
+      };
+    } catch (error) {
+      logger.error(
+        "Error in tps_audit",
+        error instanceof Error ? error : new Error(String(error))
+      );
+      return formatError(error);
+    }
+  }
+);
 server.registerTool(
   "list_review_config",
   { description: "Show current model configuration" },
@@ -718,6 +1993,23 @@ server.registerTool(
     };
   }
 );
+createConversationTool(
+  server,
+  {
+    name: "discuss_with_council",
+    description: "Start or continue a multi-turn discussion with the AI council. First call (without session_id) starts a new discussion and returns a session_id. Subsequent calls with the session_id continue the conversation. Each model maintains its own conversation history for authentic perspectives.",
+    inputSchema: discussCouncilSchema,
+    handler: (input, store) => handleDiscussCouncil(client, input, store)
+  },
+  sessionStore
+);
+function handleShutdown(signal) {
+  logger.info(`Received ${signal}, shutting down gracefully`);
+  sessionStore.shutdown();
+  process.exit(0);
+}
+process.on("SIGTERM", () => handleShutdown("SIGTERM"));
+process.on("SIGINT", () => handleShutdown("SIGINT"));
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -725,7 +2017,9 @@ async function main() {
     codeReviewModels: CODE_REVIEW_MODELS,
     frontendReviewModels: FRONTEND_REVIEW_MODELS,
     backendReviewModels: BACKEND_REVIEW_MODELS,
-    planReviewModels: PLAN_REVIEW_MODELS
+    planReviewModels: PLAN_REVIEW_MODELS,
+    discussionModels: DISCUSSION_MODELS,
+    tpsAuditModels: TPS_AUDIT_MODELS
   });
 }
 main().catch((error) => {