@codemcp/workflows 6.4.0 → 6.5.1

package/packages/mcp-server/dist/index.js

@@ -2650,25 +2650,21 @@ var LogLevel;
   LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
   LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
 })(LogLevel || (LogLevel = {}));
-var mcpServerInstance = null;
+var logSinkInstance = null;
 var currentLoggingLevel = null;
 function isTestMode() {
-  if (process.env.NODE_ENV === "test" || process.env.VITEST === "true") {
+  if (process.env["NODE_ENV"] === "test" || process.env["VITEST"] === "true") {
     return true;
   }
-  const cwd = process.cwd();
-  if (cwd.includes("/tmp/") || cwd.includes("temp") || cwd.includes("test-")) {
-    return true;
-  }
-  if (process.env.LOG_LEVEL === "ERROR") {
+  if (process.env["LOG_LEVEL"] === "ERROR") {
     return true;
   }
   return false;
 }
-function setMcpServerForLogging(server) {
-  mcpServerInstance = server;
+function registerLogSink(sink) {
+  logSinkInstance = sink;
 }
-function setMcpLoggingLevel(level) {
+function setLoggingLevelFromString(level) {
   const levelMap = {
     debug: LogLevel.DEBUG,
     info: LogLevel.INFO,
@@ -2708,7 +2704,7 @@ var Logger = class _Logger {
     return LogLevel.INFO;
   }
   getLogLevelFromEnv() {
-    const envLevel = process.env.LOG_LEVEL?.toUpperCase();
+    const envLevel = process.env["LOG_LEVEL"]?.toUpperCase();
     switch (envLevel) {
       case "DEBUG":
         return LogLevel.DEBUG;
@@ -2733,31 +2729,15 @@ var Logger = class _Logger {
     return `[${timestamp2}] ${level.toUpperCase()} [${this.component}] ${message}${contextStr}`;
   }
   /**
-   * Send log message to MCP client if server is available and level is appropriate
+   * Send log message to registered sink if available
    */
-  async sendMcpLogMessage(level, message, context) {
-    if (mcpServerInstance) {
+  async sendToSink(level, message, context) {
+    if (logSinkInstance) {
       try {
-        let logData = message;
-        if (context) {
-          try {
-            const contextStr = JSON.stringify(context, null, 0);
-            logData = `${message} ${contextStr}`;
-          } catch (_error) {
-            logData = `${message} [context serialization failed]`;
-          }
-        }
-        await mcpServerInstance.server.notification({
-          method: "notifications/message",
-          params: {
-            level,
-            logger: this.component,
-            data: logData
-          }
-        });
+        await logSinkInstance.log(level, this.component, message, context);
       } catch (error) {
         if (!isTestMode()) {
-          process.stderr.write(`[MCP-LOG-ERROR] Failed to send log notification: ${error}
+          process.stderr.write(`[LOG-SINK-ERROR] Failed to send log to sink: ${error}
 `);
         }
       }
@@ -2765,85 +2745,42 @@ var Logger = class _Logger {
   }
   debug(message, context) {
     if (this.shouldLog(LogLevel.DEBUG)) {
-      const formattedMessage = this.formatMessage("debug", message, context);
-      process.stderr.write(formattedMessage + "\n");
-      this.sendMcpLogMessage("debug", message, context).catch(() => {
+      if (!logSinkInstance) {
+        const formattedMessage = this.formatMessage("debug", message, context);
+        process.stderr.write(formattedMessage + "\n");
+      }
+      this.sendToSink("debug", message, context).catch(() => {
       });
     }
   }
   info(message, context) {
     if (this.shouldLog(LogLevel.INFO)) {
-      const formattedMessage = this.formatMessage("info", message, context);
-      process.stderr.write(formattedMessage + "\n");
-      this.sendEnhancedMcpNotification("info", message, context).catch(() => {
-      });
-    }
-  }
-  /**
-   * Send enhanced MCP notifications with better formatting for important events
-   */
-  async sendEnhancedMcpNotification(level, message, context) {
-    if (mcpServerInstance) {
-      try {
-        let enhancedMessage = message;
-        let notificationLevel = level;
-        if (context && (context.from || context.to) && message.includes("transition")) {
-          const from = context.from ? this.capitalizePhase(context.from) : "";
-          const to = context.to ? this.capitalizePhase(context.to) : "";
-          if (from && to) {
-            enhancedMessage = `Phase Transition: ${from} \u2192 ${to}`;
-            notificationLevel = "info";
-          }
-        }
-        if (message.includes("initialized successfully")) {
-          enhancedMessage = "\u{1F680} Vibe Feature MCP Server Ready";
-          notificationLevel = "info";
-        }
-        let logData = enhancedMessage;
-        if (context) {
-          try {
-            const contextStr = JSON.stringify(context, null, 0);
-            logData = `${enhancedMessage} ${contextStr}`;
-          } catch (_error) {
-            logData = `${enhancedMessage} [context serialization failed]`;
-          }
-        }
-        await mcpServerInstance.server.notification({
-          method: "notifications/message",
-          params: {
-            level: notificationLevel,
-            logger: this.component,
-            data: logData
-          }
-        });
-      } catch (error) {
-        if (!isTestMode()) {
-          process.stderr.write(`[MCP-LOG-ERROR] Failed to send log notification: ${error}
-`);
-        }
+      if (!logSinkInstance) {
+        const formattedMessage = this.formatMessage("info", message, context);
+        process.stderr.write(formattedMessage + "\n");
       }
+      this.sendToSink("info", message, context).catch(() => {
+      });
     }
   }
-  /**
-   * Capitalize phase name for display
-   */
-  capitalizePhase(phase) {
-    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
   warn(message, context) {
     if (this.shouldLog(LogLevel.WARN)) {
-      const formattedMessage = this.formatMessage("warn", message, context);
-      process.stderr.write(formattedMessage + "\n");
-      this.sendEnhancedMcpNotification("warning", message, context).catch(() => {
+      if (!logSinkInstance) {
+        const formattedMessage = this.formatMessage("warn", message, context);
+        process.stderr.write(formattedMessage + "\n");
+      }
+      this.sendToSink("warning", message, context).catch(() => {
       });
     }
   }
   error(message, error, context) {
     if (this.shouldLog(LogLevel.ERROR)) {
       const errorContext = error ? { ...context, error: error.message, stack: error.stack } : context;
-      const formattedMessage = this.formatMessage("error", message, errorContext);
-      process.stderr.write(formattedMessage + "\n");
-      this.sendEnhancedMcpNotification("error", message, errorContext).catch(() => {
+      if (!logSinkInstance) {
+        const formattedMessage = this.formatMessage("error", message, errorContext);
+        process.stderr.write(formattedMessage + "\n");
+      }
+      this.sendToSink("error", message, errorContext).catch(() => {
       });
     }
   }
@@ -2854,7 +2791,7 @@ var Logger = class _Logger {
 function createLogger(component, logLevel) {
   return new Logger(component, logLevel);
 }
-var logger = createLogger("VibeFeatureMCP");
+var logger = createLogger("workflows-core");
 
 // ../core/dist/state-machine-loader.js
 var logger2 = createLogger("StateMachineLoader");
@@ -3080,6 +3017,35 @@ ${continueTransition.additional_instructions}`;
     }
     return stateDefinition.default_instructions;
   }
+  /**
+   * Get allowed file patterns for a specific phase.
+   * Returns undefined if no restrictions are defined (all files allowed).
+   *
+   * @param phase - The phase/state name to get patterns for
+   * @returns Array of glob patterns or undefined if all files are allowed
+   */
+  getAllowedFilePatterns(phase) {
+    if (!this.stateMachine) {
+      throw new Error("State machine not loaded");
+    }
+    const stateDefinition = this.stateMachine.states[phase];
+    if (!stateDefinition) {
+      logger2.error("Unknown phase", new Error(`Unknown phase: ${phase}`));
+      throw new Error(`Unknown phase: ${phase}`);
+    }
+    return stateDefinition.allowed_file_patterns;
+  }
+  /**
+   * Whether the given phase restricts which files may be edited.
+   * Returns false when no allowed_file_patterns are defined (all files allowed).
+   * Callers should use getAllowedFilePatterns + a glob library for actual path matching.
+   *
+   * @param phase - The phase/state name
+   */
+  hasFileRestrictions(phase) {
+    const patterns = this.getAllowedFilePatterns(phase);
+    return patterns !== void 0 && patterns.length > 0;
+  }
 };
 
 // ../core/dist/workflow-manager.js
@@ -3161,13 +3127,21 @@ var WorkflowManager = class _WorkflowManager {
   }
   /**
    * Parse enabled domains from environment variable
+   * Supports both WORKFLOW_DOMAINS and VIBE_WORKFLOW_DOMAINS (legacy)
+   * WORKFLOW_DOMAINS takes precedence if both are set (modern, non-prefixed version preferred)
    */
   parseEnabledDomains() {
-    const domainsEnv = process.env["VIBE_WORKFLOW_DOMAINS"];
+    const domainsEnv = process.env["WORKFLOW_DOMAINS"] || process.env["VIBE_WORKFLOW_DOMAINS"];
     if (!domainsEnv) {
+      logger4.debug("No domain configuration found, using default: code");
       return /* @__PURE__ */ new Set(["code"]);
     }
-    return new Set(domainsEnv.split(",").map((d) => d.trim()).filter((d) => d));
+    const domains = new Set(domainsEnv.split(",").map((d) => d.trim()).filter((d) => d));
+    logger4.debug("Parsed enabled domains", {
+      source: process.env["WORKFLOW_DOMAINS"] ? "WORKFLOW_DOMAINS" : "VIBE_WORKFLOW_DOMAINS",
+      domains: Array.from(domains)
+    });
+    return domains;
   }
   /**
    * Load project-specific workflows from .vibe/workflows/
@@ -3540,16 +3514,21 @@ var WorkflowManager = class _WorkflowManager {
   }
 };
 
+// ../core/dist/string-utils.js
+function capitalizePhase(phase) {
+  return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
 // ../core/dist/transition-engine.js
-var logger5 = createLogger("TransitionEngine");
+var defaultLogger = createLogger("TransitionEngine");
 var TransitionEngine = class {
-  stateMachineLoader;
   workflowManager;
+  logger;
   conversationManager;
-  constructor(projectPath) {
-    this.stateMachineLoader = new StateMachineLoader();
+  constructor(projectPath, logger24 = defaultLogger) {
     this.workflowManager = new WorkflowManager();
-    logger5.info("TransitionEngine initialized", { projectPath });
+    this.logger = logger24;
+    this.logger.info("TransitionEngine initialized", { projectPath });
   }
   /**
    * Set the conversation manager (dependency injection)
@@ -3568,11 +3547,11 @@ var TransitionEngine = class {
    */
   async isFirstCallFromInitialState(context) {
     if (!this.conversationManager) {
-      logger5.warn("ConversationManager not set, assuming first call");
+      this.logger.warn("ConversationManager not set, assuming first call");
       return true;
     }
     const hasInteractions = await this.conversationManager.hasInteractions(context.conversationId);
-    logger5.debug("Checking first call from initial state", {
+    this.logger.debug("Checking first call from initial state", {
       hasInteractions,
       conversationId: context.conversationId,
       currentPhase: context.currentPhase
@@ -3582,51 +3561,18 @@ var TransitionEngine = class {
   /**
    * Generate instructions for defining phase entrance criteria
    */
-  async generateCriteriaDefinitionInstructions(projectPath, conversationId) {
-    const conversationState = await this.conversationManager?.getConversationState(conversationId);
-    const workflowName = conversationState?.workflowName;
-    const stateMachine = this.workflowManager.loadWorkflowForProject(projectPath, workflowName);
+  generateCriteriaDefinitionInstructions(stateMachine) {
     const phases = Object.keys(stateMachine.states);
-    let instructions = `Welcome to ${stateMachine.name}!
-
-Before we begin development, let's establish clear entrance criteria for each phase. This will help us make informed decisions about when to transition between phases throughout the development process.
-
-Please update the plan file with a "Phase Entrance Criteria" section that defines specific, measurable criteria for entering each phase:
-
-## Phase Entrance Criteria
-
-`;
-    for (const phase of phases) {
-      if (phase === stateMachine.initial_state)
-        continue;
-      const phaseDefinition = stateMachine.states[phase];
-      const capitalizedPhase = this.capitalizePhase(phase);
-      instructions += `### ${capitalizedPhase} Phase
-*${phaseDefinition.description}*
-
-**Enter when:**
-- [ ] [Define specific criteria for entering ${phase} phase]
-- [ ] [Add measurable conditions that must be met]
-- [ ] [Include any deliverables or milestones required]
-
-`;
-    }
-    instructions += `
-Once you've defined these criteria, we can begin development. Throughout the process, consult these criteria when considering phase transitions.
-
-**Remember**: These criteria should be specific and measurable so we can clearly determine when each phase is ready to begin.`;
-    return instructions;
+    const phaseList = phases.filter((phase) => phase !== stateMachine.initial_state).map((phase) => capitalizePhase(phase)).join(", ");
+    return `Define entrance criteria for each phase (${phaseList}) in the plan file. Criteria should be specific and measurable.`;
   }
   /**
    * Get phase-specific instructions for continuing work in current phase
    */
-  async getContinuePhaseInstructions(phase, projectPath, conversationId) {
-    const conversationState = await this.conversationManager?.getConversationState(conversationId);
-    const workflowName = conversationState?.workflowName;
-    const stateMachine = this.workflowManager.loadWorkflowForProject(projectPath, workflowName);
+  getContinuePhaseInstructions(phase, stateMachine) {
     const stateDefinition = stateMachine.states[phase];
     if (!stateDefinition) {
-      logger5.error("Unknown phase", new Error(`Unknown phase: ${phase}`));
+      this.logger.error("Unknown phase", new Error(`Unknown phase: ${phase}`));
       throw new Error(`Unknown phase: ${phase}`);
     }
     const continueTransition = stateDefinition.transitions.find((t) => t.to === phase);
@@ -3649,19 +3595,17 @@ ${continueTransition.additional_instructions}`;
   /**
    * Get the first development phase from the state machine
    */
-  async getFirstDevelopmentPhase(projectPath, conversationId) {
-    const conversationState = await this.conversationManager?.getConversationState(conversationId);
-    const workflowName = conversationState?.workflowName;
-    const stateMachine = this.workflowManager.loadWorkflowForProject(projectPath, workflowName);
-    const initialState = stateMachine.initial_state;
-    return initialState;
+  getFirstDevelopmentPhase(stateMachine) {
+    return stateMachine.initial_state;
   }
   /**
    * Analyze context and determine appropriate phase transition
    */
   async analyzePhaseTransition(context) {
     const { currentPhase, projectPath, conversationId, userInput, context: additionalContext, conversationSummary } = context;
-    logger5.debug("Analyzing phase transition", {
+    const conversationState = await this.conversationManager?.getConversationState(conversationId);
+    const stateMachine = this.workflowManager.loadWorkflowForProject(projectPath, conversationState?.workflowName);
+    this.logger.debug("Analyzing phase transition", {
       currentPhase,
       projectPath,
       hasUserInput: !!userInput,
@@ -3670,14 +3614,14 @@ ${continueTransition.additional_instructions}`;
       userInput: userInput ? userInput.substring(0, 50) + (userInput.length > 50 ? "..." : "") : void 0
     });
     if (await this.isFirstCallFromInitialState(context)) {
-      const firstDevelopmentPhase = await this.getFirstDevelopmentPhase(projectPath, conversationId);
-      logger5.info("First call from initial state - transitioning to first development phase with criteria", {
+      const firstDevelopmentPhase = this.getFirstDevelopmentPhase(stateMachine);
+      this.logger.info("First call from initial state - transitioning to first development phase with criteria", {
         currentPhase,
         firstDevelopmentPhase,
         projectPath
       });
-      const criteriaInstructions = await this.generateCriteriaDefinitionInstructions(projectPath, conversationId);
-      const phaseInstructions = await this.getContinuePhaseInstructions(firstDevelopmentPhase, projectPath, conversationId);
+      const criteriaInstructions = this.generateCriteriaDefinitionInstructions(stateMachine);
+      const phaseInstructions = this.getContinuePhaseInstructions(firstDevelopmentPhase, stateMachine);
       return {
         newPhase: firstDevelopmentPhase,
         // Transition to first development phase
@@ -3686,8 +3630,8 @@ ${continueTransition.additional_instructions}`;
         isModeled: true
       };
     }
-    const continueInstructions = await this.getContinuePhaseInstructions(currentPhase, projectPath, conversationId);
-    logger5.debug("Continuing in current phase - LLM will evaluate transition criteria", {
+    const continueInstructions = this.getContinuePhaseInstructions(currentPhase, stateMachine);
+    this.logger.debug("Continuing in current phase - LLM will evaluate transition criteria", {
       currentPhase,
       projectPath
     });
@@ -3703,7 +3647,7 @@ ${continueTransition.additional_instructions}`;
    */
   handleExplicitTransition(currentPhase, targetPhase, projectPath, reason, workflowName) {
     const stateMachine = this.getStateMachine(projectPath, workflowName);
-    logger5.debug("Handling explicit phase transition", {
+    this.logger.debug("Handling explicit phase transition", {
       currentPhase,
       targetPhase,
       projectPath,
@@ -3714,7 +3658,7 @@ ${continueTransition.additional_instructions}`;
     if (!stateMachine.states[normalizedTargetPhase]) {
       const validPhases = Object.keys(stateMachine.states);
       const errorMsg = `Invalid target phase: "${targetPhase}". Valid phases are: ${validPhases.join(", ")}`;
-      logger5.error("Invalid target phase", new Error(errorMsg));
+      this.logger.error("Invalid target phase", new Error(errorMsg));
       throw new Error(errorMsg);
     }
     const targetState = stateMachine.states[normalizedTargetPhase];
@@ -3725,7 +3669,7 @@ ${continueTransition.additional_instructions}`;
       isModeled: false
       // Direct phase transitions are not modeled
     };
-    logger5.info("Explicit phase transition processed", {
+    this.logger.info("Explicit phase transition processed", {
       fromPhase: currentPhase,
       toPhase: normalizedTargetPhase,
       reason: transitionInfo.transitionReason,
@@ -3738,12 +3682,6 @@ ${continueTransition.additional_instructions}`;
       isModeled: transitionInfo.isModeled
     };
   }
-  /**
-   * Capitalize phase name for display
-   */
-  capitalizePhase(phase) {
-    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
   /**
    * Filter transitions based on agent role (for crowd workflows)
    * Returns transitions applicable to the current agent
@@ -3759,7 +3697,7 @@ ${continueTransition.additional_instructions}`;
 // ../core/dist/file-storage.js
 import { promises as fs4 } from "fs";
 import { join, dirname } from "path";
-var logger6 = createLogger("FileStorage");
+var logger5 = createLogger("FileStorage");
 var FileStorage = class {
   conversationsDir;
   basePath;
@@ -3777,11 +3715,11 @@ var FileStorage = class {
   async initialize() {
     try {
       await fs4.mkdir(this.conversationsDir, { recursive: true });
-      logger6.debug("FileStorage initialized", {
+      logger5.debug("FileStorage initialized", {
         conversationsDir: this.conversationsDir
       });
     } catch (error) {
-      logger6.error("Failed to initialize FileStorage", error);
+      logger5.error("Failed to initialize FileStorage", error);
       throw error;
     }
   }
@@ -3831,12 +3769,12 @@ var FileStorage = class {
       await fs4.mkdir(conversationDir, { recursive: true });
       const stateJson = JSON.stringify(state, null, 2);
       await this.writeAtomic(stateFilePath, stateJson);
-      logger6.debug("Conversation state saved", {
+      logger5.debug("Conversation state saved", {
         conversationId: state.conversationId,
         currentPhase: state.currentPhase
       });
     } catch (error) {
-      logger6.error("Failed to save conversation state", error, {
+      logger5.error("Failed to save conversation state", error, {
         conversationId: state.conversationId
       });
       throw error;
@@ -3856,7 +3794,7 @@ var FileStorage = class {
       if (error.code === "ENOENT") {
         return null;
       }
-      logger6.warn("Failed to read conversation state, returning null", {
+      logger5.warn("Failed to read conversation state, returning null", {
         conversationId,
         error: error.message
       });
@@ -3888,7 +3826,7 @@ var FileStorage = class {
       if (error.code === "ENOENT") {
         return [];
       }
-      logger6.error("Failed to get all conversation states", error);
+      logger5.error("Failed to get all conversation states", error);
       throw error;
     }
   }
@@ -3900,13 +3838,13 @@ var FileStorage = class {
     const conversationDir = this.getConversationDir(conversationId);
     try {
       await fs4.rm(conversationDir, { recursive: true, force: true });
-      logger6.debug("Conversation state deleted", { conversationId });
+      logger5.debug("Conversation state deleted", { conversationId });
       return true;
     } catch (error) {
       if (error.code === "ENOENT") {
         return false;
       }
-      logger6.error("Failed to delete conversation state", error, {
+      logger5.error("Failed to delete conversation state", error, {
         conversationId
       });
       throw error;
@@ -3923,12 +3861,12 @@ var FileStorage = class {
       await fs4.mkdir(conversationDir, { recursive: true });
       const logLine = JSON.stringify(log) + "\n";
       await fs4.appendFile(interactionsFilePath, logLine, "utf-8");
-      logger6.debug("Interaction logged", {
+      logger5.debug("Interaction logged", {
         conversationId: log.conversationId,
         toolName: log.toolName
       });
     } catch (error) {
-      logger6.error("Failed to log interaction", error, {
+      logger5.error("Failed to log interaction", error, {
         conversationId: log.conversationId,
         toolName: log.toolName
       });
@@ -3950,7 +3888,7 @@ var FileStorage = class {
           const log = JSON.parse(line);
           logs.push(log);
         } catch {
-          logger6.warn("Skipping corrupted interaction log line", {
+          logger5.warn("Skipping corrupted interaction log line", {
             conversationId
           });
         }
@@ -3960,7 +3898,7 @@ var FileStorage = class {
       if (error.code === "ENOENT") {
         return [];
       }
-      logger6.error("Failed to get interaction logs", error, {
+      logger5.error("Failed to get interaction logs", error, {
         conversationId
       });
       throw error;
@@ -3980,12 +3918,12 @@ var FileStorage = class {
     const interactionsFilePath = this.getInteractionsFilePath(conversationId);
     try {
       await fs4.unlink(interactionsFilePath);
-      logger6.debug("Interaction logs deleted", { conversationId });
+      logger5.debug("Interaction logs deleted", { conversationId });
     } catch (error) {
       if (error.code === "ENOENT") {
         return;
       }
-      logger6.warn("Failed to delete interaction logs", {
+      logger5.warn("Failed to delete interaction logs", {
         conversationId,
         error: error.message
       });
@@ -4004,13 +3942,13 @@ var FileStorage = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     await this.saveConversationState(updatedState);
-    logger6.debug("Conversation state reset", { conversationId });
+    logger5.debug("Conversation state reset", { conversationId });
   }
   /**
    * Close file storage (no-op for file-based storage)
    */
   async close() {
-    logger6.debug("FileStorage closed");
+    logger5.debug("FileStorage closed");
   }
 };
 
@@ -4022,7 +3960,7 @@ import { existsSync } from "fs";
 // ../core/dist/path-validation-utils.js
 import { access, stat } from "fs/promises";
 import { resolve, isAbsolute, join as join2, normalize, basename } from "path";
-var logger7 = createLogger("PathValidationUtils");
+var logger6 = createLogger("PathValidationUtils");
 var PathValidationUtils = class {
   /**
    * Validate if a string is a known template name
@@ -4050,7 +3988,7 @@ var PathValidationUtils = class {
           error: "Path points to a directory, not a file"
         };
       }
-      logger7.debug("File path validated successfully", {
+      logger6.debug("File path validated successfully", {
         originalPath: filePath,
         resolvedPath
       });
@@ -4060,7 +3998,7 @@ var PathValidationUtils = class {
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger7.debug("File path validation failed", {
+      logger6.debug("File path validation failed", {
         filePath,
         error: errorMessage
       });
@@ -4090,7 +4028,7 @@ var PathValidationUtils = class {
           error: "Path is neither a file nor a directory"
         };
       }
-      logger7.debug("File or directory path validated successfully", {
+      logger6.debug("File or directory path validated successfully", {
         originalPath: filePath,
         resolvedPath,
         isFile: stats.isFile(),
@@ -4102,7 +4040,7 @@ var PathValidationUtils = class {
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger7.debug("File or directory path validation failed", {
+      logger6.debug("File or directory path validation failed", {
         filePath,
         error: errorMessage
       });
@@ -4217,7 +4155,7 @@ function getPathBasename(filePath, fallback = "unknown") {
 import { writeFile, readFile, access as access2 } from "fs/promises";
 import { dirname as dirname2 } from "path";
 import { mkdir } from "fs/promises";
-var logger8 = createLogger("PlanManager");
+var logger7 = createLogger("PlanManager");
 var PlanManager = class {
   stateMachine = null;
   /**
@@ -4225,7 +4163,7 @@ var PlanManager = class {
    */
   setStateMachine(stateMachine) {
     this.stateMachine = stateMachine;
-    logger8.debug("State machine set for plan manager", {
+    logger7.debug("State machine set for plan manager", {
       name: stateMachine.name,
       phases: Object.keys(stateMachine.states)
     });
@@ -4234,7 +4172,7 @@ var PlanManager = class {
    * Set the task backend configuration
    */
   setTaskBackend(taskBackend) {
-    logger8.debug("Task backend set for plan manager (markdown mode)", {
+    logger7.debug("Task backend set for plan manager (markdown mode)", {
       backend: taskBackend.backend,
       available: taskBackend.isAvailable
     });
@@ -4262,43 +4200,43 @@ var PlanManager = class {
    * Create initial plan file if it doesn't exist
    */
   async ensurePlanFile(planFilePath, projectPath, gitBranch) {
-    logger8.debug("Ensuring plan file exists", {
+    logger7.debug("Ensuring plan file exists", {
       planFilePath,
       projectPath,
       gitBranch
     });
     const planInfo = await this.getPlanFileInfo(planFilePath);
     if (!planInfo.exists) {
-      logger8.info("Plan file not found, creating initial plan", {
+      logger7.info("Plan file not found, creating initial plan", {
         planFilePath
       });
       await this.createInitialPlanFile(planFilePath, projectPath, gitBranch);
-      logger8.info("Initial plan file created successfully", { planFilePath });
+      logger7.info("Initial plan file created successfully", { planFilePath });
     } else {
-      logger8.debug("Plan file already exists", { planFilePath });
+      logger7.debug("Plan file already exists", { planFilePath });
     }
   }
   /**
    * Create initial plan file with template content
    */
   async createInitialPlanFile(planFilePath, projectPath, gitBranch) {
-    logger8.debug("Creating initial plan file", { planFilePath });
+    logger7.debug("Creating initial plan file", { planFilePath });
     try {
       await mkdir(dirname2(planFilePath), { recursive: true });
-      logger8.debug("Plan file directory ensured", {
+      logger7.debug("Plan file directory ensured", {
         directory: dirname2(planFilePath)
       });
       const projectName = getPathBasename(projectPath, "Unknown Project");
       const branchInfo = gitBranch !== "no-git" ? ` (${gitBranch} branch)` : "";
       const initialContent = this.generateInitialPlanContent(projectName, branchInfo);
       await writeFile(planFilePath, initialContent, "utf-8");
-      logger8.info("Initial plan file written successfully", {
+      logger7.info("Initial plan file written successfully", {
         planFilePath,
         contentLength: initialContent.length,
         projectName
       });
     } catch (error) {
-      logger8.error("Failed to create initial plan file", error, {
+      logger7.error("Failed to create initial plan file", error, {
         planFilePath
       });
       throw error;
@@ -4330,7 +4268,7 @@ var PlanManager = class {
 *Additional context and observations*
 
 `;
-    content += `## ${this.capitalizePhase(initialPhase)}
+    content += `## ${capitalizePhase(initialPhase)}
 ### Tasks
 - [ ] *Tasks will be added as they are identified*
 
@@ -4340,7 +4278,7 @@ var PlanManager = class {
 `;
     for (const phase of phases) {
       if (phase !== initialPhase) {
-        content += `## ${this.capitalizePhase(phase)}
+        content += `## ${capitalizePhase(phase)}
 ### Tasks
 - [ ] *To be added when this phase becomes active*
 
@@ -4392,31 +4330,31 @@ var PlanManager = class {
     }
     const phaseDefinition = this.stateMachine.states[phase];
     if (!phaseDefinition) {
-      logger8.warn("Unknown phase for plan file guidance", { phase });
-      return `Update the ${this.capitalizePhase(phase)} section with current progress and mark completed tasks.`;
+      logger7.warn("Unknown phase for plan file guidance", { phase });
+      return `Update the ${capitalizePhase(phase)} section with current progress and mark completed tasks.`;
     }
-    const capitalizedPhase = this.capitalizePhase(phase);
+    const capitalizedPhase = capitalizePhase(phase);
     return `Update the ${capitalizedPhase} section with progress. Mark completed tasks with [x] and add new tasks as they are identified.`;
   }
   /**
    * Delete plan file
    */
   async deletePlanFile(planFilePath) {
-    logger8.debug("Deleting plan file", { planFilePath });
+    logger7.debug("Deleting plan file", { planFilePath });
     try {
       await access2(planFilePath);
       const { unlink: unlink2 } = await import("fs/promises");
       await unlink2(planFilePath);
-      logger8.info("Plan file deleted successfully", { planFilePath });
+      logger7.info("Plan file deleted successfully", { planFilePath });
       return true;
     } catch (error) {
       if (error.code === "ENOENT") {
-        logger8.debug("Plan file does not exist, nothing to delete", {
+        logger7.debug("Plan file does not exist, nothing to delete", {
           planFilePath
         });
         return true;
       }
-      logger8.error("Failed to delete plan file", error, {
+      logger7.error("Failed to delete plan file", error, {
         planFilePath
       });
       throw error;
@@ -4426,32 +4364,26 @@ var PlanManager = class {
    * Ensure plan file is deleted (verify deletion)
    */
   async ensurePlanFileDeleted(planFilePath) {
-    logger8.debug("Ensuring plan file is deleted", { planFilePath });
+    logger7.debug("Ensuring plan file is deleted", { planFilePath });
     try {
       await access2(planFilePath);
-      logger8.warn("Plan file still exists after deletion attempt", {
+      logger7.warn("Plan file still exists after deletion attempt", {
         planFilePath
       });
       return false;
     } catch (error) {
       if (error.code === "ENOENT") {
-        logger8.debug("Plan file successfully deleted (does not exist)", {
+        logger7.debug("Plan file successfully deleted (does not exist)", {
           planFilePath
         });
         return true;
       }
-      logger8.error("Error checking plan file deletion", error, {
+      logger7.error("Error checking plan file deletion", error, {
         planFilePath
       });
       throw error;
     }
   }
-  /**
-   * Capitalize phase name for display
-   */
-  capitalizePhase(phase) {
-    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
   /**
    * Generate workflow documentation URL for predefined workflows
    * Returns undefined for custom workflows
@@ -4462,10 +4394,24 @@ var PlanManager = class {
     }
     return `https://mrsimpson.github.io/responsible-vibe-mcp/workflows/${workflowName}`;
   }
+  /**
+   * Generate base instructions for the LLM after a workflow is started.
+   * Instructs the LLM to populate the Goal section and define phase entrance
+   * criteria in the freshly created plan file.
+   */
+  getInitialPlanGuidance(planFilePath, workflowDocUrl) {
+    const docInfo = workflowDocUrl ? `
+
+Inform the user about the chosen workflow. They can visit: ${workflowDocUrl} to get detailed information.` : "";
+    const i18nNote = `
+
+NOTE: If the user is communicating in a non-English language, translate plan file content to that language while keeping markdown headers (##, ###) in English to maintain structure parsing. Continue all interactions in the user's language.`;
+    return `**Read ${planFilePath}** to understand the workflow structure. Add entrance criteria for each phase (what must be true to enter), then call \`whats_next()\`.${docInfo}${i18nNote}`;
+  }
 };
 
 // ../core/dist/conversation-manager.js
-var logger9 = createLogger("ConversationManager");
+var logger8 = createLogger("ConversationManager");
 var ConversationManager = class {
   database;
   projectPath;
@@ -4492,11 +4438,11 @@ var ConversationManager = class {
   async getConversationContext() {
     const projectPath = this.getProjectPath();
     const gitBranch = this.getGitBranch(projectPath);
-    logger9.debug("Getting conversation context", { projectPath, gitBranch });
+    logger8.debug("Getting conversation context", { projectPath, gitBranch });
     const conversationId = this.generateConversationId(projectPath, gitBranch);
     const state = await this.database.getConversationState(conversationId);
     if (!state) {
-      logger9.warn("No conversation found for context", {
+      logger8.warn("No conversation found for context", {
         projectPath,
         gitBranch,
         conversationId
@@ -4525,7 +4471,7 @@ var ConversationManager = class {
   async createConversationContext(workflowName, projectPathOverride) {
     const projectPath = projectPathOverride || this.getProjectPath();
     const gitBranch = this.getGitBranch(projectPath);
-    logger9.debug("Creating conversation context", {
+    logger8.debug("Creating conversation context", {
       projectPath,
       gitBranch,
       workflowName
@@ -4535,14 +4481,14 @@ var ConversationManager = class {
     if (existingState) {
       if (existingState.workflowName !== workflowName) {
         const errorMessage = `Development conversation already exists with workflow '${existingState.workflowName}'. Cannot change to '${workflowName}'. Use reset_development() first to start with a new workflow.`;
-        logger9.error("Attempted workflow change on existing conversation", new Error(errorMessage), {
+        logger8.error("Attempted workflow change on existing conversation", new Error(errorMessage), {
           existingWorkflow: existingState.workflowName,
           requestedWorkflow: workflowName,
           conversationId
         });
         throw new Error(errorMessage);
       }
-      logger9.debug("Conversation already exists, returning existing context", {
+      logger8.debug("Conversation already exists, returning existing context", {
         conversationId
       });
       return {
@@ -4571,7 +4517,7 @@ var ConversationManager = class {
    * @param updates - Partial state updates to apply
    */
   async updateConversationState(conversationId, updates) {
-    logger9.debug("Updating conversation state", { conversationId, updates });
+    logger8.debug("Updating conversation state", { conversationId, updates });
     const currentState = await this.database.getConversationState(conversationId);
     if (!currentState) {
       throw new Error(`Conversation state not found for ID: ${conversationId}`);
@@ -4582,7 +4528,7 @@ var ConversationManager = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     await this.database.saveConversationState(updatedState);
-    logger9.info("Conversation state updated", {
+    logger8.info("Conversation state updated", {
       conversationId,
       currentPhase: updatedState.currentPhase
     });
@@ -4595,7 +4541,7 @@ var ConversationManager = class {
    * @param gitBranch - Git branch name
    */
   async createNewConversationState(conversationId, projectPath, gitBranch, workflowName = "waterfall") {
-    logger9.info("Creating new conversation state", {
+    logger8.info("Creating new conversation state", {
       conversationId,
       projectPath,
       gitBranch
@@ -4619,7 +4565,7 @@ var ConversationManager = class {
       updatedAt: timestamp2
     };
     await this.database.saveConversationState(newState);
-    logger9.info("New conversation state created", {
+    logger8.info("New conversation state created", {
       conversationId,
       planFilePath,
       initialPhase
@@ -4662,7 +4608,7 @@ var ConversationManager = class {
   getGitBranch(projectPath) {
     try {
       if (!existsSync(`${projectPath}/.git`)) {
-        logger9.debug('Not a git repository, using "default" as branch name', {
+        logger8.debug('Not a git repository, using "default" as branch name', {
           projectPath
         });
         return "default";
@@ -4673,10 +4619,10 @@ var ConversationManager = class {
         stdio: ["ignore", "pipe", "ignore"]
         // Suppress stderr
       }).trim();
-      logger9.debug("Detected git branch", { projectPath, branch });
+      logger8.debug("Detected git branch", { projectPath, branch });
       return branch;
     } catch (_error) {
-      logger9.debug('Failed to get git branch, using "default" as branch name', {
+      logger8.debug('Failed to get git branch, using "default" as branch name', {
         projectPath
       });
       return "default";
@@ -4690,13 +4636,13 @@ var ConversationManager = class {
     try {
       const interactions = await this.database.getInteractionsByConversationId(conversationId);
       const count = interactions.length;
-      logger9.debug("Checked interaction count for conversation", {
+      logger8.debug("Checked interaction count for conversation", {
         conversationId,
         count
       });
       return count > 0;
     } catch (error) {
-      logger9.error("Failed to check interaction count", error, {
+      logger8.error("Failed to check interaction count", error, {
         conversationId
       });
       return false;
@@ -4706,24 +4652,24 @@ var ConversationManager = class {
    * Reset conversation data (hybrid approach)
    */
   async resetConversation(confirm, reason) {
-    logger9.info("Starting conversation reset", { confirm, reason });
+    logger8.info("Starting conversation reset", { confirm, reason });
     this.validateResetRequest(confirm);
     const context = await this.getConversationContext();
     const resetItems = [];
     try {
       await this.database.softDeleteInteractionLogs(context.conversationId);
       resetItems.push("interaction_logs");
-      logger9.debug("Interaction logs soft deleted");
+      logger8.debug("Interaction logs soft deleted");
       await this.database.deleteConversationState(context.conversationId);
       resetItems.push("conversation_state");
-      logger9.debug("Conversation state hard deleted");
+      logger8.debug("Conversation state hard deleted");
       const planManager = new PlanManager();
       await planManager.deletePlanFile(context.planFilePath);
       resetItems.push("plan_file");
-      logger9.debug("Plan file deleted");
+      logger8.debug("Plan file deleted");
       await this.verifyResetCleanup(context.conversationId, context.planFilePath);
       const message = `Successfully reset conversation ${context.conversationId}. Reset items: ${resetItems.join(", ")}${reason ? `. Reason: ${reason}` : ""}`;
-      logger9.info("Conversation reset completed successfully", {
+      logger8.info("Conversation reset completed successfully", {
         conversationId: context.conversationId,
         resetItems,
         reason
@@ -4735,7 +4681,7 @@ var ConversationManager = class {
         message
       };
     } catch (error) {
-      logger9.error("Failed to reset conversation", error, {
+      logger8.error("Failed to reset conversation", error, {
         conversationId: context.conversationId,
         resetItems,
         reason
@@ -4755,7 +4701,7 @@ var ConversationManager = class {
    * Verify that reset cleanup was successful
    */
   async verifyResetCleanup(conversationId, planFilePath) {
-    logger9.debug("Verifying reset cleanup", { conversationId, planFilePath });
+    logger8.debug("Verifying reset cleanup", { conversationId, planFilePath });
     try {
       const state = await this.database.getConversationState(conversationId);
       if (state) {
@@ -4766,9 +4712,9 @@ var ConversationManager = class {
       if (!isDeleted) {
         throw new Error("Plan file was not properly deleted");
       }
-      logger9.debug("Reset cleanup verification successful");
+      logger8.debug("Reset cleanup verification successful");
     } catch (error) {
-      logger9.error("Reset cleanup verification failed", error);
+      logger8.error("Reset cleanup verification failed", error);
       throw error;
     }
   }
@@ -4776,13 +4722,13 @@ var ConversationManager = class {
    * Clean up conversation data (used internally)
    */
   async cleanupConversationData(conversationId) {
-    logger9.debug("Cleaning up conversation data", { conversationId });
+    logger8.debug("Cleaning up conversation data", { conversationId });
     try {
       await this.database.softDeleteInteractionLogs(conversationId);
       await this.database.deleteConversationState(conversationId);
-      logger9.debug("Conversation data cleanup completed", { conversationId });
+      logger8.debug("Conversation data cleanup completed", { conversationId });
     } catch (error) {
-      logger9.error("Failed to cleanup conversation data", error, {
+      logger8.error("Failed to cleanup conversation data", error, {
         conversationId
       });
       throw error;
@@ -4795,7 +4741,7 @@ import { readFile as readFile2, readdir, stat as stat2 } from "fs/promises";
 import { join as join3, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { createRequire as createRequire3 } from "module";
-var logger10 = createLogger("TemplateManager");
+var logger9 = createLogger("TemplateManager");
 var TemplateManager = class {
   templatesPath;
   constructor() {
@@ -4824,13 +4770,13 @@ var TemplateManager = class {
     for (const strategy of strategies) {
       try {
         __require("fs").accessSync(strategy);
-        logger10.debug("Using templates path", { path: strategy });
+        logger9.debug("Using templates path", { path: strategy });
         return strategy;
       } catch (_error) {
       }
     }
     const fallback = strategies[0];
-    logger10.warn("No templates directory found, using fallback", {
+    logger9.warn("No templates directory found, using fallback", {
       fallback,
       strategies
     });
@@ -4884,7 +4830,7 @@ var TemplateManager = class {
       const content = await readFile2(templateFilePath, "utf-8");
       return { content };
     } catch (error) {
-      logger10.error(`Failed to load template: ${type2}/${template}`, error);
+      logger9.error(`Failed to load template: ${type2}/${template}`, error);
       throw new Error(`Template not found: ${type2}/${template}. Tried: ${templatePath} (directory) and ${templateFilePath} (file)`);
     }
   }
@@ -4965,16 +4911,16 @@ var TemplateManager = class {
           }
           templates.sort();
         } catch (error) {
-          logger10.warn(`Failed to scan templates for type: ${type2}`, {
+          logger9.warn(`Failed to scan templates for type: ${type2}`, {
             typePath,
             error: error instanceof Error ? error.message : String(error)
           });
         }
       }
-      logger10.debug("Discovered available templates", result);
+      logger9.debug("Discovered available templates", result);
       return result;
     } catch (error) {
-      logger10.error("Failed to discover templates", error);
+      logger9.error("Failed to discover templates", error);
       return result;
     }
   }
@@ -4983,12 +4929,14 @@ var TemplateManager = class {
 // ../core/dist/project-docs-manager.js
 import { writeFile as writeFile2, access as access3, mkdir as mkdir2, unlink, symlink, lstat, stat as stat3, readdir as readdir2 } from "fs/promises";
 import { join as join4, dirname as dirname4, relative, extname, basename as basename2 } from "path";
-var logger11 = createLogger("ProjectDocsManager");
+var defaultLogger2 = createLogger("ProjectDocsManager");
 var ProjectDocsManager = class {
   templateManager;
   // Make public for access from other classes
-  constructor() {
+  logger;
+  constructor(logger24 = defaultLogger2) {
     this.templateManager = new TemplateManager();
+    this.logger = logger24;
   }
   /**
    * Get project docs directory path
@@ -5159,7 +5107,7 @@ var ProjectDocsManager = class {
     } else {
       skipped.push("design.md");
     }
-    logger11.info("Project docs creation/linking completed", {
+    this.logger.info("Project docs creation/linking completed", {
       created,
       linked,
       skipped,
@@ -5178,13 +5126,13 @@ var ProjectDocsManager = class {
       const targetDir = dirname4(targetPath);
       const relativePath = relative(targetDir, sourcePath);
       await symlink(relativePath, targetPath);
-      logger11.debug("Symlink created successfully", {
+      this.logger.debug("Symlink created successfully", {
         sourcePath,
         targetPath,
         relativePath
       });
     } catch (error) {
-      logger11.error("Failed to create symlink", error, {
+      this.logger.error("Failed to create symlink", error, {
         sourcePath,
         targetPath
       });
@@ -5198,14 +5146,14 @@ var ProjectDocsManager = class {
     try {
       const stats = await lstat(documentPath);
       await unlink(documentPath);
-      logger11.debug("Existing document removed", {
+      this.logger.debug("Existing document removed", {
         documentPath,
         wasSymlink: stats.isSymbolicLink()
       });
     } catch (error) {
       const nodeError = error;
       if (error instanceof Error && "code" in nodeError && nodeError.code !== "ENOENT") {
-        logger11.debug("Failed to remove existing document", {
+        this.logger.debug("Failed to remove existing document", {
           documentPath,
           error: nodeError.message
         });
@@ -5227,9 +5175,9 @@ var ProjectDocsManager = class {
           await writeFile2(filePath, file.content.toString());
         }
       }
-      logger11.debug(`Created ${type2} document`, { documentPath, template });
+      this.logger.debug(`Created ${type2} document`, { documentPath, template });
     } catch (error) {
-      logger11.error(`Failed to create ${type2} document`, error, {
+      this.logger.error(`Failed to create ${type2} document`, error, {
         documentPath,
         template
       });
@@ -5300,12 +5248,12 @@ var ProjectDocsManager = class {
 // ../core/dist/file-detection-manager.js
 import { readdir as readdir3, access as access4 } from "fs/promises";
 import { join as join5, basename as basename3 } from "path";
-var logger12 = createLogger("FileDetectionManager");
+var logger10 = createLogger("FileDetectionManager");
 
 // ../core/dist/git-manager.js
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
-var logger13 = createLogger("GitManager");
+var logger11 = createLogger("GitManager");
 var GitManager = class {
   /**
    * Check if a directory is a git repository
@@ -5319,7 +5267,7 @@ var GitManager = class {
   static getCurrentBranch(projectPath) {
     try {
       if (!this.isGitRepository(projectPath)) {
-        logger13.debug('Not a git repository, using "default" as branch name', {
+        logger11.debug('Not a git repository, using "default" as branch name', {
           projectPath
         });
         return "default";
@@ -5329,10 +5277,10 @@ var GitManager = class {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
-      logger13.debug("Detected git branch", { projectPath, branch });
+      logger11.debug("Detected git branch", { projectPath, branch });
       return branch;
     } catch (_error) {
-      logger13.debug('Failed to get git branch, using "default" as branch name', {
+      logger11.debug('Failed to get git branch, using "default" as branch name', {
         projectPath
       });
       return "default";
@@ -5353,7 +5301,7 @@ var GitManager = class {
       }).trim();
       return hash;
     } catch (error) {
-      logger13.debug("Failed to get current commit hash", { projectPath, error });
+      logger11.debug("Failed to get current commit hash", { projectPath, error });
       return null;
     }
   }
@@ -5363,7 +5311,7 @@ var GitManager = class {
   static createCommit(message, projectPath) {
     try {
       if (!this.isGitRepository(projectPath)) {
-        logger13.debug("Not a git repository, skipping commit", { projectPath });
+        logger11.debug("Not a git repository, skipping commit", { projectPath });
         return false;
       }
       execSync2("git add .", {
@@ -5376,10 +5324,10 @@ var GitManager = class {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
       });
-      logger13.debug("Created commit successfully", { projectPath, message });
+      logger11.debug("Created commit successfully", { projectPath, message });
       return true;
     } catch (error) {
-      logger13.debug("Failed to create commit", {
+      logger11.debug("Failed to create commit", {
         projectPath,
         message,
         error: error instanceof Error ? error.message : String(error)
@@ -5393,7 +5341,7 @@ var GitManager = class {
   static hasUncommittedChanges(projectPath) {
     try {
       if (!this.isGitRepository(projectPath)) {
-        logger13.debug("Not a git repository, no uncommitted changes", {
+        logger11.debug("Not a git repository, no uncommitted changes", {
           projectPath
         });
         return false;
@@ -5404,13 +5352,13 @@ var GitManager = class {
         stdio: ["ignore", "pipe", "ignore"]
       }).trim();
       const hasChanges = status.length > 0;
-      logger13.debug("Checked for uncommitted changes", {
+      logger11.debug("Checked for uncommitted changes", {
         projectPath,
         hasChanges
       });
       return hasChanges;
     } catch (error) {
-      logger13.debug("Failed to check for uncommitted changes", {
+      logger11.debug("Failed to check for uncommitted changes", {
         projectPath,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -5421,7 +5369,7 @@ var GitManager = class {
 
 // ../core/dist/task-backend.js
 import { execSync as execSync3 } from "child_process";
-var logger14 = createLogger("TaskBackend");
+var defaultLogger3 = createLogger("TaskBackend");
 var TaskBackendManager = class _TaskBackendManager {
   /**
    * Detect and validate the requested task backend
@@ -5433,18 +5381,19 @@ var TaskBackendManager = class _TaskBackendManager {
    * When TASK_BACKEND is explicitly set:
    * - Uses the specified backend (markdown or beads)
    * - For beads, validates availability and provides setup instructions if not available
+   *
    */
-  static detectTaskBackend() {
+  static detectTaskBackend(logger24 = defaultLogger3) {
     const envBackend = process.env["TASK_BACKEND"]?.toLowerCase().trim();
     if (envBackend && !["markdown", "beads"].includes(envBackend)) {
-      logger14.debug("Invalid TASK_BACKEND value, treating as not set", {
+      logger24.debug("Invalid TASK_BACKEND value, treating as not set", {
         envBackend
       });
     }
     if (!envBackend || !["markdown", "beads"].includes(envBackend)) {
-      const beadsAvailable2 = _TaskBackendManager.checkBeadsAvailability();
+      const beadsAvailable2 = _TaskBackendManager.checkBeadsAvailability(logger24);
       if (beadsAvailable2.isAvailable) {
-        logger14.info("Auto-detected beads backend (bd command available)", {
+        logger24.debug("Auto-detected beads backend (bd command available)", {
           reason: "TASK_BACKEND not set, bd command found"
         });
         return {
@@ -5452,7 +5401,7 @@ var TaskBackendManager = class _TaskBackendManager {
           isAvailable: true
         };
       }
-      logger14.debug("Using markdown backend (bd command not available)", {
+      logger24.debug("Using markdown backend (bd command not available)", {
         reason: "TASK_BACKEND not set, bd command not found"
       });
       return {
@@ -5462,15 +5411,15 @@ var TaskBackendManager = class _TaskBackendManager {
     }
     const backend = envBackend;
     if (backend === "markdown") {
-      logger14.debug("Using explicitly configured markdown backend");
+      logger24.debug("Using explicitly configured markdown backend");
       return {
         backend: "markdown",
         isAvailable: true
       };
     }
-    const beadsAvailable = _TaskBackendManager.checkBeadsAvailability();
+    const beadsAvailable = _TaskBackendManager.checkBeadsAvailability(logger24);
     if (beadsAvailable.isAvailable) {
-      logger14.debug("Using explicitly configured beads backend");
+      logger24.debug("Using explicitly configured beads backend");
       return {
         backend: "beads",
         isAvailable: true
@@ -5485,14 +5434,14 @@ var TaskBackendManager = class _TaskBackendManager {
   /**
    * Check if beads command is available and functional
    */
-  static checkBeadsAvailability() {
+  static checkBeadsAvailability(logger24 = defaultLogger3) {
     try {
       const output = execSync3("bd --version", {
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "pipe"],
         timeout: 5e3
       });
-      logger14.debug("Beads command available", { version: output.trim() });
+      logger24.debug("Beads command available", { version: output.trim() });
       return { isAvailable: true };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -5508,7 +5457,7 @@ var TaskBackendManager = class _TaskBackendManager {
           errorMessage: "Beads command (bd) timed out. Check if beads is properly installed and configured."
         };
       }
-      logger14.warn("Beads availability check failed", { errorMessage });
+      logger24.warn("Beads availability check failed", { errorMessage });
       return {
         isAvailable: false,
         errorMessage: `Beads command (bd) check failed: ${errorMessage}`
@@ -5561,9 +5510,10 @@ export TASK_BACKEND=markdown
   }
   /**
    * Validate task backend configuration and throw error if invalid
+   *
    */
-  static validateTaskBackend() {
-    const config = this.detectTaskBackend();
+  static validateTaskBackend(logger24 = defaultLogger3) {
+    const config = this.detectTaskBackend(logger24);
     if (!config.isAvailable) {
       const setupInstructions = config.backend === "beads" ? this.getBeadsSetupInstructions() : "Task backend validation failed";
       throw new Error(`Task backend '${config.backend}' is not available.
@@ -5572,7 +5522,7 @@ ${config.errorMessage || ""}
 
 ${setupInstructions}`);
     }
-    logger14.info("Task backend validated successfully", {
+    logger24.info("Task backend validated successfully", {
       backend: config.backend,
       available: config.isAvailable
     });
@@ -5582,11 +5532,13 @@ ${setupInstructions}`);
 
 // ../core/dist/beads-integration.js
 import { execSync as execSync4 } from "child_process";
-var logger15 = createLogger("BeadsIntegration");
+var defaultLogger4 = createLogger("BeadsIntegration");
 var BeadsIntegration = class {
   projectPath;
-  constructor(projectPath) {
+  logger;
+  constructor(projectPath, logger24 = defaultLogger4) {
     this.projectPath = projectPath;
+    this.logger = logger24;
   }
   /**
    * Ensure beads is initialized in the project directory
@@ -5602,7 +5554,7 @@ var BeadsIntegration = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       if (errorMessage.includes("not initialized") || errorMessage.includes("no database") || errorMessage.includes("init")) {
-        logger15.info("Beads not initialized, running bd init --no-db", {
+        this.logger.info("Beads not initialized, running bd init --no-db", {
           projectPath: this.projectPath
         });
         try {
@@ -5611,12 +5563,12 @@ var BeadsIntegration = class {
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "pipe"]
           });
-          logger15.info("Successfully initialized beads in project", {
+          this.logger.info("Successfully initialized beads in project", {
             projectPath: this.projectPath
           });
         } catch (initError) {
           const initErrorMessage = initError instanceof Error ? initError.message : String(initError);
-          logger15.error("Failed to initialize beads", initError instanceof Error ? initError : new Error(initErrorMessage), { projectPath: this.projectPath });
+          this.logger.error("Failed to initialize beads", initError instanceof Error ? initError : new Error(initErrorMessage), { projectPath: this.projectPath });
           throw new Error(`Failed to initialize beads: ${initErrorMessage}`);
         }
       } else {
@@ -5634,7 +5586,7 @@ var BeadsIntegration = class {
     const epicDescription = description || `Responsible vibe engineering session using ${workflowName} workflow for ${projectName}`;
     const priority = 2;
     const command = `bd create "${epicTitle}" --description "${epicDescription}" --priority ${priority}`;
-    logger15.debug("Creating beads project epic", {
+    this.logger.debug("Creating beads project epic", {
       command,
       projectName,
       workflowName,
@@ -5648,7 +5600,7 @@ var BeadsIntegration = class {
       });
       const match = output.match(/✓ Created issue: ([\w\d.-]+)/) || output.match(/Created issue: ([\w\d.-]+)/) || output.match(/Created (bd-[\w\d.]+)/);
       if (!match) {
-        logger15.warn("Failed to extract task ID from beads output", {
+        this.logger.warn("Failed to extract task ID from beads output", {
           command: `bd create "${epicTitle}" --description "${epicDescription}" --priority 2`,
           output: output.slice(0, 200)
           // Truncated for logging
@@ -5656,7 +5608,7 @@ var BeadsIntegration = class {
         throw new Error(`Failed to extract task ID from beads output: ${output.slice(0, 100)}...`);
       }
       const epicId = match[1] || "";
-      logger15.info("Created beads project epic", {
+      this.logger.info("Created beads project epic", {
         epicId,
         epicTitle,
         projectPath: this.projectPath
@@ -5670,10 +5622,10 @@ var BeadsIntegration = class {
         workflowName,
         projectPath: this.projectPath
       };
-      logger15.error("Failed to create beads project epic", error instanceof Error ? error : new Error(errorMessage), commandInfo);
+      this.logger.error("Failed to create beads project epic", error instanceof Error ? error : new Error(errorMessage), commandInfo);
       const execError = error;
       if (execError?.stderr) {
-        logger15.error("Beads command stderr output", new Error("Command stderr"), {
+        this.logger.error("Beads command stderr output", new Error("Command stderr"), {
           stderr: execError.stderr.toString(),
           ...commandInfo
         });
@@ -5689,12 +5641,12 @@ var BeadsIntegration = class {
     const phaseTasks = [];
     const phaseNames = Object.keys(phases);
     for (const phase of phaseNames) {
-      const phaseTitle = `${this.capitalizePhase(phase)}`;
+      const phaseTitle = capitalizePhase(phase);
       const priority = 3;
       const stateDefinition = phases[phase];
       const description = (stateDefinition?.default_instructions || `${workflowName} workflow ${phase} phase tasks`).replace(/"/g, '\\"').replace(/\n/g, " ").replace(/\r/g, "").trim();
       const command = `bd create "${phaseTitle}" --description "${description}" --parent ${epicId} --priority ${priority}`;
-      logger15.debug("Creating beads phase task", {
+      this.logger.debug("Creating beads phase task", {
         command,
         phase,
         epicId,
@@ -5708,7 +5660,7 @@ var BeadsIntegration = class {
         });
         const match = output.match(/✓ Created issue: ([\w\d.-]+)/) || output.match(/Created issue: ([\w\d.-]+)/) || output.match(/Created (bd-[\w\d.]+)/);
         if (!match) {
-          logger15.warn("Failed to extract phase task ID from beads output", {
+          this.logger.warn("Failed to extract phase task ID from beads output", {
             command,
             output: output.slice(0, 200)
             // Truncated for logging
@@ -5721,7 +5673,7 @@ var BeadsIntegration = class {
           phaseName: phaseTitle,
           taskId: phaseTaskId
         });
-        logger15.debug("Created beads phase task", {
+        this.logger.debug("Created beads phase task", {
           phase,
           phaseTaskId,
           epicId,
@@ -5735,10 +5687,10 @@ var BeadsIntegration = class {
           epicId,
           projectPath: this.projectPath
         };
-        logger15.error("Failed to create beads phase task", error instanceof Error ? error : new Error(errorMessage), commandInfo);
+        this.logger.error("Failed to create beads phase task", error instanceof Error ? error : new Error(errorMessage), commandInfo);
         const execError = error;
         if (execError?.stderr) {
-          logger15.error("Beads phase command stderr output", new Error("Command stderr"), {
+          this.logger.error("Beads phase command stderr output", new Error("Command stderr"), {
             stderr: execError.stderr.toString(),
             ...commandInfo
           });
@@ -5746,7 +5698,7 @@ var BeadsIntegration = class {
         throw new Error(`Failed to create beads phase task for ${phase}: ${errorMessage}`);
       }
     }
-    logger15.info("Created all beads phase tasks", {
+    this.logger.info("Created all beads phase tasks", {
       count: phaseTasks.length,
       epicId,
       projectPath: this.projectPath
@@ -5759,13 +5711,13 @@ var BeadsIntegration = class {
    */
   async createPhaseDependencies(phaseTasks) {
     if (phaseTasks.length < 2) {
-      logger15.debug("Skipping phase dependencies - less than 2 phases", {
+      this.logger.debug("Skipping phase dependencies - less than 2 phases", {
         phaseCount: phaseTasks.length,
         projectPath: this.projectPath
       });
       return;
     }
-    logger15.info("Creating sequential phase dependencies", {
+    this.logger.info("Creating sequential phase dependencies", {
       phaseCount: phaseTasks.length,
       projectPath: this.projectPath
     });
@@ -5774,7 +5726,7 @@ var BeadsIntegration = class {
       const currentPhase = phaseTasks[i];
       const nextPhase = phaseTasks[i + 1];
       if (!currentPhase || !nextPhase) {
-        logger15.warn("Skipping phase dependency - missing phase data", {
+        this.logger.warn("Skipping phase dependency - missing phase data", {
           currentPhaseIndex: i,
           nextPhaseIndex: i + 1,
           totalPhases: phaseTasks.length,
@@ -5788,7 +5740,7 @@ var BeadsIntegration = class {
         continue;
       }
       const command = `bd dep ${currentPhase.taskId} --blocks ${nextPhase.taskId}`;
-      logger15.debug("Creating phase dependency", {
+      this.logger.debug("Creating phase dependency", {
         command,
         currentPhase: currentPhase.phaseName,
         nextPhase: nextPhase.phaseName,
@@ -5802,14 +5754,14 @@ var BeadsIntegration = class {
           encoding: "utf-8",
           stdio: ["ignore", "pipe", "pipe"]
         });
-        logger15.debug("Successfully created phase dependency", {
+        this.logger.debug("Successfully created phase dependency", {
           currentPhase: currentPhase.phaseName,
           nextPhase: nextPhase.phaseName,
           projectPath: this.projectPath
         });
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger15.warn("Failed to create phase dependency - continuing anyway", {
+        this.logger.warn("Failed to create phase dependency - continuing anyway", {
           error: errorMessage,
           command,
           currentPhase: currentPhase.phaseName,
@@ -5818,7 +5770,7 @@ var BeadsIntegration = class {
         });
         const execError = error;
         if (execError?.stderr) {
-          logger15.debug("Beads dependency command stderr", {
+          this.logger.debug("Beads dependency command stderr", {
             stderr: execError.stderr.toString(),
             command,
             projectPath: this.projectPath
@@ -5832,25 +5784,19 @@ var BeadsIntegration = class {
       }
     }
     if (failedDependencies.length > 0) {
-      logger15.warn("Some phase dependencies could not be created - app continues without these dependencies", {
+      this.logger.warn("Some phase dependencies could not be created - app continues without these dependencies", {
         failedCount: failedDependencies.length,
         failedDependencies,
         projectPath: this.projectPath
       });
     }
-    logger15.info("Completed phase dependency creation", {
+    this.logger.info("Completed phase dependency creation", {
       dependencyCount: phaseTasks.length - 1,
       successCount: phaseTasks.length - 1 - failedDependencies.length,
       failedCount: failedDependencies.length,
       projectPath: this.projectPath
     });
   }
-  /**
-   * Capitalize phase name for display
-   */
-  capitalizePhase(phase) {
-    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
   /**
    * Validate parameters for epic creation
    */
@@ -5898,11 +5844,13 @@ var BeadsIntegration = class {
 // ../core/dist/beads-state-manager.js
 import { writeFile as writeFile3, readFile as readFile3, mkdir as mkdir3, access as access5 } from "fs/promises";
 import { join as join6, dirname as dirname5 } from "path";
-var logger16 = createLogger("BeadsStateManager");
+var defaultLogger5 = createLogger("BeadsStateManager");
 var BeadsStateManager = class {
   projectPath;
-  constructor(projectPath) {
+  logger;
+  constructor(projectPath, logger24 = defaultLogger5) {
     this.projectPath = projectPath;
+    this.logger = logger24;
   }
   /**
    * Get the path to the beads state file for a conversation
@@ -5923,7 +5871,7 @@ var BeadsStateManager = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     await this.saveState(state);
-    logger16.info("Created beads conversation state", {
+    this.logger.info("Created beads conversation state", {
       conversationId,
       epicId,
       phaseCount: phaseTasks.length,
@@ -5940,7 +5888,7 @@ var BeadsStateManager = class {
       await access5(statePath);
       const content = await readFile3(statePath, "utf-8");
       const state = JSON.parse(content);
-      logger16.debug("Retrieved beads conversation state", {
+      this.logger.debug("Retrieved beads conversation state", {
         conversationId,
         epicId: state.epicId,
         phaseCount: state.phaseTasks.length,
@@ -5949,14 +5897,14 @@ var BeadsStateManager = class {
       return state;
     } catch (error) {
       if (error.code === "ENOENT") {
-        logger16.debug("No beads state found for conversation", {
+        this.logger.debug("No beads state found for conversation", {
           conversationId,
           projectPath: this.projectPath
         });
         return null;
       }
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger16.warn("Failed to read beads state file", {
+      this.logger.warn("Failed to read beads state file", {
         error: errorMessage,
         conversationId,
         statePath,
@@ -5975,7 +5923,7 @@ var BeadsStateManager = class {
     }
     const phaseTask = state.phaseTasks.find((task) => task.phaseId === phase);
     if (phaseTask) {
-      logger16.debug("Found phase task ID", {
+      this.logger.debug("Found phase task ID", {
         conversationId,
         phase,
         taskId: phaseTask.taskId,
@@ -5983,7 +5931,7 @@ var BeadsStateManager = class {
       });
       return phaseTask.taskId;
     }
-    logger16.debug("No task ID found for phase", {
+    this.logger.debug("No task ID found for phase", {
       conversationId,
       phase,
       availablePhases: state.phaseTasks.map((t) => t.phaseId),
@@ -5997,7 +5945,7 @@ var BeadsStateManager = class {
   async updateState(conversationId, updates) {
     const existingState = await this.getState(conversationId);
     if (!existingState) {
-      logger16.warn("Cannot update non-existent beads state", {
+      this.logger.warn("Cannot update non-existent beads state", {
         conversationId,
         projectPath: this.projectPath
       });
@@ -6011,7 +5959,7 @@ var BeadsStateManager = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     await this.saveState(updatedState);
-    logger16.info("Updated beads conversation state", {
+    this.logger.info("Updated beads conversation state", {
       conversationId,
       updatedFields: Object.keys(updates),
       projectPath: this.projectPath
@@ -6026,21 +5974,21 @@ var BeadsStateManager = class {
     try {
       await access5(statePath);
       await writeFile3(statePath + ".backup", await readFile3(statePath));
-      logger16.info("Cleaned up beads conversation state", {
+      this.logger.info("Cleaned up beads conversation state", {
         conversationId,
         statePath,
         projectPath: this.projectPath
       });
     } catch (error) {
       if (error.code === "ENOENT") {
-        logger16.debug("No beads state to clean up", {
+        this.logger.debug("No beads state to clean up", {
           conversationId,
           projectPath: this.projectPath
         });
         return;
       }
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger16.warn("Failed to clean up beads state", {
+      this.logger.warn("Failed to clean up beads state", {
         error: errorMessage,
         conversationId,
         statePath,
@@ -6070,7 +6018,7 @@ var BeadsStateManager = class {
       await mkdir3(stateDir, { recursive: true });
       const content = JSON.stringify(state, null, 2);
       await writeFile3(statePath, content, "utf-8");
-      logger16.debug("Saved beads state to file", {
+      this.logger.debug("Saved beads state to file", {
         conversationId: state.conversationId,
         statePath,
         fileSize: content.length,
@@ -6078,7 +6026,7 @@ var BeadsStateManager = class {
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger16.error("Failed to save beads state", error instanceof Error ? error : new Error(errorMessage), {
+      this.logger.error("Failed to save beads state", error instanceof Error ? error : new Error(errorMessage), {
         conversationId: state.conversationId,
         statePath,
         projectPath: this.projectPath
@@ -6089,7 +6037,7 @@ var BeadsStateManager = class {
 };
 
 // ../core/dist/interaction-logger.js
-var logger17 = createLogger("InteractionLogger");
+var logger12 = createLogger("InteractionLogger");
 var InteractionLogger = class {
   database;
   /**
@@ -6099,7 +6047,7 @@ var InteractionLogger = class {
    */
   constructor(database) {
     this.database = database;
-    logger17.debug("InteractionLogger initialized");
+    logger12.debug("InteractionLogger initialized");
   }
   /**
    * Log an interaction with a tool
@@ -6112,7 +6060,7 @@ var InteractionLogger = class {
    * @returns Promise that resolves when the log is saved
    */
   async logInteraction(conversationId, toolName, inputParams, responseData, currentPhase) {
-    logger17.debug("Logging interaction", {
+    logger12.debug("Logging interaction", {
       conversationId,
       toolName,
       currentPhase
@@ -6128,13 +6076,13 @@ var InteractionLogger = class {
         timestamp: timestamp2
       };
       await this.database.logInteraction(log);
-      logger17.info("Interaction logged successfully", {
+      logger12.info("Interaction logged successfully", {
         conversationId,
         toolName,
         timestamp: timestamp2
       });
     } catch (error) {
-      logger17.error("Failed to log interaction", error, {
+      logger12.error("Failed to log interaction", error, {
         conversationId,
         toolName
       });
@@ -6147,16 +6095,16 @@ var InteractionLogger = class {
    * @returns Promise that resolves to an array of interaction logs
    */
   async getInteractionsByConversationId(conversationId) {
-    logger17.debug("Getting interactions by conversation ID", { conversationId });
+    logger12.debug("Getting interactions by conversation ID", { conversationId });
     try {
       const logs = await this.database.getInteractionsByConversationId(conversationId);
-      logger17.info("Retrieved interaction logs", {
+      logger12.info("Retrieved interaction logs", {
         conversationId,
         count: logs.length
       });
       return logs;
     } catch (error) {
-      logger17.error("Failed to get interaction logs", error, {
+      logger12.error("Failed to get interaction logs", error, {
         conversationId
       });
       throw error;
@@ -6167,11 +6115,11 @@ var InteractionLogger = class {
 // ../core/dist/instruction-generator.js
 var InstructionGenerator = class {
   projectDocsManager;
-  constructor(_planManager) {
-    this.projectDocsManager = new ProjectDocsManager();
+  constructor(logger24 = createLogger("InstructionGenerator")) {
+    this.projectDocsManager = new ProjectDocsManager(logger24);
   }
   /**
-   * Set the state machine definition for dynamic instruction generation
+   * No-op: all phase context is provided per-call via InstructionContext.
    */
   setStateMachine(_stateMachine) {
     return;
@@ -6184,7 +6132,6 @@ var InstructionGenerator = class {
     const enhancedInstructions = await this.enhanceInstructions(substitutedInstructions, context);
     return {
       instructions: enhancedInstructions,
-      planFileGuidance: "Task management guidance is now included in main instructions",
       metadata: {
         phase: context.phase,
         planFilePath: context.conversationContext.planFilePath,
@@ -6215,43 +6162,36 @@ var InstructionGenerator = class {
    * Enhance base instructions with context-specific information
    */
   async enhanceInstructions(baseInstructions, context) {
-    const { phase, conversationContext, planFileExists } = context;
-    const phaseName = this.capitalizePhase(phase);
+    const { phase, conversationContext, allowedFilePatterns } = context;
+    const phaseName = capitalizePhase(phase);
     let workflowSection = `---
-**Workflow Continuity:**
-Maintain \`${conversationContext.planFilePath}\`:
-- Work through tasks in the "${phaseName}" section; Focus on those tasks!
-- Add newly discovered tasks; log decisions in "Key Decisions"
-- DO NOT maintain tasks in other tools or documents than explicitly stated in this plan file!`;
-    if (!planFileExists) {
-      workflowSection += "\n- Note: plan file will be created on first update";
-    }
-    workflowSection += "\n\nCall `whats_next()` after each user message.";
+**Read \`${conversationContext.planFilePath}\`** for context.
+- Focus on "${phaseName}" tasks, log decisions in "Key Decisions"
+- Do NOT use other task/todo tools - use only the plan file for task tracking`;
+    if (allowedFilePatterns && allowedFilePatterns.length > 0 && !allowedFilePatterns.includes("**/*") && !allowedFilePatterns.includes("*")) {
+      workflowSection += `
+- Files allowed: \`${allowedFilePatterns.join("`, `")}\``;
+    }
+    workflowSection += "\n\nCall `whats_next()` after user messages.";
     return `## ${phaseName} Phase
 
 ${baseInstructions}
 
 ${workflowSection}`;
   }
-  /**
-   * Capitalize phase name for display
-   */
-  capitalizePhase(phase) {
-    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
 };
 
 // ../core/dist/system-prompt-generator.js
-var logger18 = createLogger("SystemPromptGenerator");
+var logger13 = createLogger("SystemPromptGenerator");
 function generateSystemPrompt(stateMachine) {
-  logger18.debug("Generating system prompt from state machine definition", {
+  logger13.debug("Generating system prompt from state machine definition", {
     stateMachineName: stateMachine.name,
     phaseCount: Object.keys(stateMachine.states).length
   });
   return generateSimpleSystemPrompt(stateMachine);
 }
 function generateSimpleSystemPrompt(_stateMachine) {
-  logger18.debug("Generating system prompt");
+  logger13.debug("Generating system prompt");
   const systemPrompt = `
 You are an AI assistant that helps users develop software features using the workflows server.
 
@@ -6262,7 +6202,7 @@ Each tool call returns a JSON response with an "instructions" field. Follow thes
 Use the development plan which you will retrieve via whats_next() to record important insights and decisions as per the structure of the plan.
 
 Do not use your own task management tools.`;
-  logger18.info("System prompt generated successfully", {
+  logger13.info("System prompt generated successfully", {
     promptLength: systemPrompt.length
   });
   return systemPrompt;
@@ -6277,12 +6217,13 @@ import * as path4 from "path";
 
 // src/server-helpers.ts
 import { homedir } from "os";
-var logger19 = createLogger("ServerHelpers");
-function normalizeProjectPath(projectPath) {
+var defaultLogger6 = createLogger("ServerHelpers");
+function normalizeProjectPath(projectPath, logger24) {
+  const log = logger24 ?? defaultLogger6;
   const path6 = projectPath || process.cwd();
   if (path6 === "/" || path6 === "") {
     const homePath = homedir();
-    logger19.info("Invalid project path detected, using home directory", {
+    log.info("Invalid project path detected, using home directory", {
       originalPath: path6,
       normalizedPath: homePath
     });
@@ -6305,14 +6246,18 @@ function createErrorResult(error, metadata) {
     metadata
   };
 }
-async function safeExecute(operation, errorContext) {
+async function safeExecute(operation, errorContext, logger24) {
+  const log = logger24 ?? defaultLogger6;
   try {
     const result = await operation();
     return createSuccessResult(result);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";
     const contextualError = errorContext ? `${errorContext}: ${errorMessage}` : errorMessage;
-    logger19.error("Operation failed", error, { errorContext });
+    const isExpectedError = errorMessage.includes("CONVERSATION_NOT_FOUND") || errorMessage.includes("Invalid workflow:");
+    if (!isExpectedError) {
+      log.error("Operation failed", error, { errorContext });
+    }
     return createErrorResult(contextualError);
   }
 }
@@ -6376,14 +6321,16 @@ function generateWorkflowDescription(workflows) {
   description += "\u2022 **custom**: Use custom workflow from .vibe/workflows in your project\n\n";
   return description;
 }
-function logHandlerExecution(handlerName, args) {
-  logger19.debug(`Executing ${handlerName} handler`, {
+function logHandlerExecution(handlerName, args, logger24) {
+  const log = logger24 ?? defaultLogger6;
+  log.debug(`Executing ${handlerName} handler`, {
     handlerName,
     argsKeys: Object.keys(args || {})
   });
 }
-function logHandlerCompletion(handlerName, result) {
-  logger19.debug(`Completed ${handlerName} handler`, {
+function logHandlerCompletion(handlerName, result, logger24) {
+  const log = logger24 ?? defaultLogger6;
+  log.debug(`Completed ${handlerName} handler`, {
     handlerName,
     success: result.success,
     hasData: !!result.data,
@@ -6415,12 +6362,14 @@ var notificationService = new NotificationService();
 var PluginRegistry = class {
   plugins = /* @__PURE__ */ new Map();
   /**
-   * Register a plugin if it's enabled
+   * Register a plugin.
+   *
+   * Note: Plugins are always registered regardless of isEnabled() state.
+   * The isEnabled() check happens at hook execution time in getEnabledPlugins().
+   * This allows plugins to activate/deactivate dynamically based on conditions
+   * that may change after registration (e.g., backend availability).
    */
   registerPlugin(plugin) {
-    if (!plugin.isEnabled()) {
-      return;
-    }
     const name = plugin.getName();
     if (this.plugins.has(name)) {
       throw new Error(`Plugin with name '${name}' is already registered`);
@@ -6535,11 +6484,13 @@ var PluginRegistry = class {
 
 // src/components/beads/beads-task-backend-client.ts
 import { execSync as execSync5 } from "child_process";
-var logger20 = createLogger("BeadsTaskBackendClient");
+var defaultLogger7 = createLogger("BeadsTaskBackendClient");
 var BeadsTaskBackendClient = class {
   projectPath;
-  constructor(projectPath) {
+  logger;
+  constructor(projectPath, logger24) {
     this.projectPath = projectPath;
+    this.logger = logger24 ?? defaultLogger7;
   }
   /**
    * Execute a beads command safely
@@ -6547,7 +6498,7 @@ var BeadsTaskBackendClient = class {
   async executeBeadsCommand(args) {
     try {
       const command = `bd ${args.join(" ")}`;
-      logger20.debug("Executing beads command", {
+      this.logger.debug("Executing beads command", {
         command,
         projectPath: this.projectPath
       });
@@ -6559,7 +6510,7 @@ var BeadsTaskBackendClient = class {
       return { success: true, stdout };
     } catch (error) {
       const execError = error;
-      logger20.warn("Beads command failed", {
+      this.logger.warn("Beads command failed", {
         args,
         error: error instanceof Error ? error.message : String(error),
         stderr: execError.stderr,
@@ -6692,18 +6643,29 @@ var BeadsTaskBackendClient = class {
 };
 
 // src/plugin-system/beads-plugin.ts
-var logger21 = createLogger("BeadsPlugin");
 var BeadsPlugin = class {
   projectPath;
   beadsStateManager;
   beadsTaskBackendClient;
   planManager;
+  logger;
+  loggerFactory;
   constructor(options) {
     this.projectPath = options.projectPath;
-    this.beadsStateManager = new BeadsStateManager(this.projectPath);
-    this.beadsTaskBackendClient = new BeadsTaskBackendClient(this.projectPath);
+    this.loggerFactory = options.loggerFactory;
+    this.logger = options.loggerFactory ? options.loggerFactory("BeadsPlugin") : createLogger("BeadsPlugin");
+    this.beadsStateManager = new BeadsStateManager(
+      this.projectPath,
+      options.loggerFactory ? options.loggerFactory("BeadsStateManager") : void 0
+    );
+    this.beadsTaskBackendClient = new BeadsTaskBackendClient(
+      this.projectPath,
+      options.loggerFactory ? options.loggerFactory("BeadsTaskBackendClient") : void 0
+    );
     this.planManager = new PlanManager();
-    logger21.debug("BeadsPlugin initialized", { projectPath: this.projectPath });
+    this.logger.debug("BeadsPlugin initialized", {
+      projectPath: this.projectPath
+    });
   }
   getName() {
     return "BeadsPlugin";
@@ -6712,9 +6674,9 @@ var BeadsPlugin = class {
     return 100;
   }
   isEnabled() {
-    const taskBackendConfig = TaskBackendManager.detectTaskBackend();
+    const taskBackendConfig = TaskBackendManager.detectTaskBackend(this.logger);
     const enabled = taskBackendConfig.backend === "beads" && taskBackendConfig.isAvailable;
-    logger21.debug("BeadsPlugin enablement check", {
+    this.logger.debug("BeadsPlugin enablement check", {
       backend: taskBackendConfig.backend,
       isAvailable: taskBackendConfig.isAvailable,
       autoDetected: !process.env["TASK_BACKEND"],
@@ -6726,7 +6688,8 @@ var BeadsPlugin = class {
     return {
       afterStartDevelopment: this.handleAfterStartDevelopment.bind(this),
       beforePhaseTransition: this.handleBeforePhaseTransition.bind(this),
-      afterPlanFileCreated: this.handleAfterPlanFileCreated.bind(this)
+      afterPlanFileCreated: this.handleAfterPlanFileCreated.bind(this),
+      afterInstructionsGenerated: this.handleAfterInstructionsGenerated.bind(this)
     };
   }
   /**
@@ -6734,7 +6697,7 @@ var BeadsPlugin = class {
    * Replaces validateBeadsTaskCompletion() method from proceed-to-phase.ts
    */
   async handleBeforePhaseTransition(context, currentPhase, targetPhase) {
-    logger21.info(
+    this.logger.info(
       "BeadsPlugin: Validating task completion before phase transition",
       {
         conversationId: context.conversationId,
@@ -6749,7 +6712,7 @@ var BeadsPlugin = class {
         targetPhase,
         context.projectPath
       );
-      logger21.info(
+      this.logger.info(
         "BeadsPlugin: Task validation passed, allowing phase transition",
         {
           conversationId: context.conversationId,
@@ -6758,7 +6721,7 @@ var BeadsPlugin = class {
         }
       );
     } catch (error) {
-      logger21.info(
+      this.logger.info(
         "BeadsPlugin: Task validation failed, blocking phase transition",
         {
           conversationId: context.conversationId,
@@ -6776,20 +6739,25 @@ var BeadsPlugin = class {
    * Implements graceful degradation: continues app operation even if beads operations fail
    */
   async handleAfterStartDevelopment(context, args, _result) {
-    logger21.info("BeadsPlugin: Setting up beads integration", {
+    this.logger.info("BeadsPlugin: Setting up beads integration", {
       conversationId: context.conversationId,
       workflow: args.workflow,
       projectPath: context.projectPath
     });
     if (!context.stateMachine) {
-      logger21.error("BeadsPlugin: State machine not provided in plugin context");
-      logger21.warn(
+      this.logger.error(
+        "BeadsPlugin: State machine not provided in plugin context"
+      );
+      this.logger.warn(
         "BeadsPlugin: Beads integration disabled - continuing without beads"
       );
       return;
     }
     try {
-      const beadsIntegration = new BeadsIntegration(context.projectPath);
+      const beadsIntegration = new BeadsIntegration(
+        context.projectPath,
+        this.loggerFactory ? this.loggerFactory("BeadsIntegration") : void 0
+      );
       const projectName = getPathBasename(
         context.projectPath,
         "Unknown Project"
@@ -6801,7 +6769,7 @@ var BeadsPlugin = class {
         );
         goalDescription = this.extractGoalFromPlan(planFileContent);
       } catch (error) {
-        logger21.warn("BeadsPlugin: Could not extract goal from plan file", {
+        this.logger.warn("BeadsPlugin: Could not extract goal from plan file", {
           error: error instanceof Error ? error.message : String(error),
           planFilePath: context.planFilePath
         });
@@ -6817,7 +6785,7 @@ var BeadsPlugin = class {
         );
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn(
+        this.logger.warn(
           "BeadsPlugin: Failed to create beads project epic - continuing without beads integration",
           {
             error: errorMsg,
@@ -6835,7 +6803,7 @@ var BeadsPlugin = class {
         );
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn(
+        this.logger.warn(
           "BeadsPlugin: Failed to create beads phase tasks - continuing without phase tracking",
           {
             error: errorMsg,
@@ -6848,7 +6816,7 @@ var BeadsPlugin = class {
         await beadsIntegration.createPhaseDependencies(phaseTasks);
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn(
+        this.logger.warn(
           "BeadsPlugin: Failed to create phase dependencies - continuing without dependencies",
           {
             error: errorMsg,
@@ -6863,7 +6831,7 @@ var BeadsPlugin = class {
         );
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn(
+        this.logger.warn(
           "BeadsPlugin: Failed to update plan file with beads task IDs - continuing without plan file updates",
           {
             error: errorMsg,
@@ -6879,7 +6847,7 @@ var BeadsPlugin = class {
         );
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn(
+        this.logger.warn(
           "BeadsPlugin: Failed to create beads state - continuing without state persistence",
           {
             error: errorMsg,
@@ -6887,7 +6855,7 @@ var BeadsPlugin = class {
           }
         );
       }
-      logger21.info("BeadsPlugin: Beads integration setup complete", {
+      this.logger.info("BeadsPlugin: Beads integration setup complete", {
         conversationId: context.conversationId,
         epicId,
         phaseCount: phaseTasks?.length || 0,
@@ -6895,7 +6863,7 @@ var BeadsPlugin = class {
       });
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger21.warn(
+      this.logger.warn(
         "BeadsPlugin: Unexpected error during beads integration setup - continuing application without beads",
         {
           error: errorMsg,
@@ -6916,11 +6884,127 @@ var BeadsPlugin = class {
    * This hook ensures the plan has the proper structure to receive them.
    */
   async handleAfterPlanFileCreated(_context, planFilePath, content) {
-    logger21.debug("BeadsPlugin: afterPlanFileCreated hook invoked", {
+    this.logger.debug("BeadsPlugin: afterPlanFileCreated hook invoked", {
       planFilePath,
       contentLength: content.length
     });
-    return content;
+    let transformed = content;
+    transformed = transformed.replace(
+      /### Tasks\n- \[ \] \*Tasks will be added as they are identified\*\n\n### Completed\n- \[x\] Created development plan file/g,
+      "<!-- beads-phase-id: TBD -->\n### Tasks\n\n*Tasks managed via `bd` CLI*"
+    );
+    transformed = transformed.replace(
+      /### Tasks\n- \[ \] \*To be added when this phase becomes active\*\n\n### Completed\n\*None yet\*/g,
+      "<!-- beads-phase-id: TBD -->\n### Tasks\n\n*Tasks managed via `bd` CLI*"
+    );
+    transformed = transformed.replace(
+      /\*This plan is maintained by the LLM\. Tool responses provide guidance on which section to focus on and what tasks to work on\.\*/,
+      "*This plan is maintained by the LLM and uses beads CLI for task management. Tool responses provide guidance on which bd commands to use for task management.*"
+    );
+    this.logger.debug("BeadsPlugin: Plan file transformed for beads", {
+      planFilePath,
+      originalLength: content.length,
+      transformedLength: transformed.length,
+      wasModified: content !== transformed
+    });
+    return transformed;
+  }
+  /**
+   * Handle afterInstructionsGenerated hook
+   * Enriches instructions with beads-specific task management guidance
+   */
+  async handleAfterInstructionsGenerated(context, instructions) {
+    this.logger.debug("BeadsPlugin: afterInstructionsGenerated hook invoked", {
+      phase: instructions.phase,
+      instructionSource: instructions.instructionSource,
+      planFilePath: instructions.planFilePath
+    });
+    const beadsGuidance = await this.generateBeadsGuidance(
+      context,
+      instructions
+    );
+    let enhanced = instructions.instructions;
+    enhanced += `
+
+Log decisions in plan file. Use ONLY \`bd\` CLI for tasks (not your own todo tools).${beadsGuidance}`;
+    if (context.planFileExists === false) {
+      enhanced += "\n\n**Note**: Plan file will be created when you first update it.";
+    }
+    enhanced += "\n\nCall `whats_next()` after user messages.";
+    this.logger.debug(
+      "BeadsPlugin: Instructions enriched with beads guidance",
+      {
+        originalLength: instructions.instructions.length,
+        enrichedLength: enhanced.length
+      }
+    );
+    return {
+      ...instructions,
+      instructions: enhanced
+    };
+  }
+  /**
+   * Generate beads-specific task management guidance
+   */
+  async generateBeadsGuidance(_context, instructions) {
+    if (instructions.instructionSource === "whats_next" || instructions.instructionSource === "start_development") {
+      const phaseTaskId = await this.extractPhaseTaskIdFromPlanFile(
+        instructions.planFilePath,
+        instructions.phase
+      );
+      if (!phaseTaskId) {
+        return `
+
+**Task Management (bd CLI):**
+Create tasks as sub-tasks of phase task: \`bd create 'title' --parent <phase-task-id>\`
+List open tasks: \`bd list --parent <phase-task-id> --status open\`
+Complete tasks: \`bd close <id>\``;
+      }
+      return `
+
+**Task Management (bd CLI) - Phase: ${phaseTaskId}**
+Create tasks as sub-tasks: \`bd create 'title' --parent ${phaseTaskId}\`
+List open tasks: \`bd list --parent ${phaseTaskId} --status open\`
+Complete tasks: \`bd close <id>\``;
+    }
+    return "";
+  }
+  /**
+   * Extract phase task ID from plan file
+   */
+  async extractPhaseTaskIdFromPlanFile(planFilePath, phase) {
+    try {
+      const { readFile: readFile5 } = await import("fs/promises");
+      const content = await readFile5(planFilePath, "utf-8");
+      const phaseName = this.capitalizePhase(phase);
+      const phaseHeader = `## ${phaseName}`;
+      const lines = content.split("\n");
+      let foundPhaseHeader = false;
+      for (const line of lines) {
+        if (line.trim() === phaseHeader) {
+          foundPhaseHeader = true;
+          continue;
+        }
+        if (foundPhaseHeader && line.includes("beads-phase-id:")) {
+          const match = line.match(/beads-phase-id:\s*([\w\d.-]+)/);
+          if (match && match[1] && match[1] !== "TBD") {
+            return match[1];
+          }
+        }
+        if (foundPhaseHeader && line.startsWith("##") && line !== phaseHeader) {
+          break;
+        }
+      }
+      return null;
+    } catch (_error) {
+      return null;
+    }
+  }
+  /**
+   * Capitalize phase name for display
+   */
+  capitalizePhase(phase) {
+    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
   }
   /**
    * Validate beads task completion before phase transition
@@ -6933,14 +7017,14 @@ var BeadsPlugin = class {
         isAvailable = await this.beadsTaskBackendClient.isAvailable();
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn("BeadsPlugin: Failed to check beads availability", {
+        this.logger.warn("BeadsPlugin: Failed to check beads availability", {
           error: errorMsg,
           conversationId
         });
         return;
       }
       if (!isAvailable) {
-        logger21.debug(
+        this.logger.debug(
           "BeadsPlugin: Skipping beads task validation - beads CLI not available",
           {
             conversationId,
@@ -6958,7 +7042,7 @@ var BeadsPlugin = class {
         );
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn("BeadsPlugin: Failed to get beads phase task ID", {
+        this.logger.warn("BeadsPlugin: Failed to get beads phase task ID", {
           error: errorMsg,
           conversationId,
           currentPhase
@@ -6966,7 +7050,7 @@ var BeadsPlugin = class {
         return;
       }
       if (!currentPhaseTaskId) {
-        logger21.debug(
+        this.logger.debug(
           "BeadsPlugin: No beads phase task ID found for current phase",
           {
             conversationId,
@@ -6977,7 +7061,7 @@ var BeadsPlugin = class {
         );
         return;
       }
-      logger21.debug(
+      this.logger.debug(
         "BeadsPlugin: Checking for incomplete beads tasks using task backend client",
         {
           conversationId,
@@ -6992,7 +7076,7 @@ var BeadsPlugin = class {
         );
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn(
+        this.logger.warn(
           "BeadsPlugin: Failed to validate tasks with beads backend",
           {
             error: errorMsg,
@@ -7004,18 +7088,9 @@ var BeadsPlugin = class {
       }
       if (!validationResult.valid) {
         const incompleteTasks = validationResult.openTasks || [];
-        const taskDetails = incompleteTasks.map((task) => `  \u2022 ${task.id} - ${task.title || "Untitled task"}`).join("\n");
-        const errorMessage = `Cannot proceed to ${targetPhase} - ${incompleteTasks.length} incomplete task(s) in current phase "${currentPhase}":
-
-${taskDetails}
-
-To proceed, check the in-progress-tasks using:
-
-   bd list --parent ${currentPhaseTaskId} --status open
-
-You can also defer tasks if they're no longer needed:
-   bd defer <task-id> --until tomorrow`;
-        logger21.info(
+        const taskIds = incompleteTasks.map((t) => t.id).join(", ");
+        const errorMessage = `${incompleteTasks.length} incomplete task(s) in ${currentPhase}: ${taskIds}. Complete or defer (\`bd defer <id>\`) before proceeding.`;
+        this.logger.info(
           "BeadsPlugin: Blocking phase transition due to incomplete beads tasks",
           {
             conversationId,
@@ -7028,7 +7103,7 @@ You can also defer tasks if they're no longer needed:
         );
         throw new Error(errorMessage);
       }
-      logger21.info(
+      this.logger.info(
         "BeadsPlugin: All beads tasks completed in current phase, allowing transition",
         {
           conversationId,
@@ -7042,7 +7117,7 @@ You can also defer tasks if they're no longer needed:
         throw error;
       }
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger21.warn(
+      this.logger.warn(
         "BeadsPlugin: Beads task validation failed, allowing transition to proceed",
         {
           error: errorMessage,
@@ -7095,13 +7170,13 @@ You can also defer tasks if they're no longer needed:
    */
   async updatePlanFileWithPhaseTaskIds(planFilePath, phaseTasks) {
     try {
-      const { readFile: readFile6, writeFile: writeFile6 } = await import("fs/promises");
+      const { readFile: readFile5, writeFile: writeFile5 } = await import("fs/promises");
       let content;
       try {
-        content = await readFile6(planFilePath, "utf-8");
+        content = await readFile5(planFilePath, "utf-8");
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn("BeadsPlugin: Failed to read plan file for update", {
+        this.logger.warn("BeadsPlugin: Failed to read plan file for update", {
           error: errorMsg,
           planFilePath
         });
@@ -7121,7 +7196,7 @@ You can also defer tasks if they're no longer needed:
       }
       const remainingTBDs = content.match(/<!-- beads-phase-id: TBD -->/g);
       if (remainingTBDs && remainingTBDs.length > 0) {
-        logger21.warn(
+        this.logger.warn(
           "BeadsPlugin: Failed to replace all TBD placeholders in plan file",
           {
             planFilePath,
@@ -7131,16 +7206,16 @@ You can also defer tasks if they're no longer needed:
         );
       }
       try {
-        await writeFile6(planFilePath, content, "utf-8");
+        await writeFile5(planFilePath, content, "utf-8");
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        logger21.warn("BeadsPlugin: Failed to write updated plan file", {
+        this.logger.warn("BeadsPlugin: Failed to write updated plan file", {
           error: errorMsg,
           planFilePath
         });
         return;
       }
-      logger21.info(
+      this.logger.info(
         "BeadsPlugin: Successfully updated plan file with beads phase task IDs",
         {
           planFilePath,
@@ -7152,7 +7227,7 @@ You can also defer tasks if they're no longer needed:
       );
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      logger21.warn(
+      this.logger.warn(
         "BeadsPlugin: Unexpected error while updating plan file with phase task IDs",
         {
           error: errorMsg,
@@ -7164,13 +7239,13 @@ You can also defer tasks if they're no longer needed:
 };
 
 // src/plugin-system/commit-plugin.ts
-var logger22 = createLogger("CommitPlugin");
+var logger14 = createLogger("CommitPlugin");
 var CommitPlugin = class {
   projectPath;
   initialCommitHash;
   constructor(options) {
     this.projectPath = options.projectPath;
-    logger22.debug("CommitPlugin initialized", { projectPath: this.projectPath });
+    logger14.debug("CommitPlugin initialized", { projectPath: this.projectPath });
   }
   getName() {
     return "CommitPlugin";
@@ -7181,7 +7256,7 @@ var CommitPlugin = class {
   isEnabled() {
     const behavior = process.env.COMMIT_BEHAVIOR;
     const enabled = behavior && ["step", "phase", "end", "none"].includes(behavior);
-    logger22.debug("CommitPlugin enablement check", {
+    logger14.debug("CommitPlugin enablement check", {
       COMMIT_BEHAVIOR: behavior,
       enabled: !!enabled
     });
@@ -7199,7 +7274,7 @@ var CommitPlugin = class {
    * Store initial commit hash for potential squashing later
    */
   async handleAfterStartDevelopment(context, _args, _result) {
-    logger22.info("CommitPlugin: Setting up commit behavior", {
+    logger14.info("CommitPlugin: Setting up commit behavior", {
       conversationId: context.conversationId,
       behavior: process.env.COMMIT_BEHAVIOR,
       projectPath: context.projectPath
@@ -7207,13 +7282,13 @@ var CommitPlugin = class {
     try {
       if (GitManager.isGitRepository(context.projectPath)) {
         this.initialCommitHash = GitManager.getCurrentCommitHash(context.projectPath) || void 0;
-        logger22.debug("CommitPlugin: Stored initial commit hash", {
+        logger14.debug("CommitPlugin: Stored initial commit hash", {
           conversationId: context.conversationId,
           initialCommitHash: this.initialCommitHash
         });
       }
     } catch (error) {
-      logger22.warn("CommitPlugin: Failed to get initial commit hash", {
+      logger14.warn("CommitPlugin: Failed to get initial commit hash", {
         error: error instanceof Error ? error.message : String(error),
         conversationId: context.conversationId
       });
@@ -7228,7 +7303,7 @@ var CommitPlugin = class {
     if (behavior !== "phase" && behavior !== "step") {
       return;
     }
-    logger22.info("CommitPlugin: Creating WIP commit before phase transition", {
+    logger14.info("CommitPlugin: Creating WIP commit before phase transition", {
       conversationId: context.conversationId,
       currentPhase,
       targetPhase,
@@ -7236,28 +7311,28 @@ var CommitPlugin = class {
     });
     try {
       if (!GitManager.isGitRepository(context.projectPath)) {
-        logger22.debug("CommitPlugin: Not a git repository, skipping commit");
+        logger14.debug("CommitPlugin: Not a git repository, skipping commit");
         return;
       }
       if (!GitManager.hasUncommittedChanges(context.projectPath)) {
-        logger22.debug("CommitPlugin: No uncommitted changes, skipping commit");
+        logger14.debug("CommitPlugin: No uncommitted changes, skipping commit");
         return;
       }
       const message = `WIP: transition to ${targetPhase}`;
       const success = GitManager.createCommit(message, context.projectPath);
       if (success) {
-        logger22.info("CommitPlugin: Created WIP commit successfully", {
+        logger14.info("CommitPlugin: Created WIP commit successfully", {
           conversationId: context.conversationId,
           message
         });
       } else {
-        logger22.warn("CommitPlugin: Failed to create WIP commit", {
+        logger14.warn("CommitPlugin: Failed to create WIP commit", {
           conversationId: context.conversationId,
           message
         });
       }
     } catch (error) {
-      logger22.warn("CommitPlugin: Error during phase transition commit", {
+      logger14.warn("CommitPlugin: Error during phase transition commit", {
         error: error instanceof Error ? error.message : String(error),
         conversationId: context.conversationId
       });
@@ -7272,7 +7347,7 @@ var CommitPlugin = class {
     if (!behavior || behavior === "none") {
       return content;
     }
-    logger22.debug("CommitPlugin: Adding final commit task to plan file", {
+    logger14.debug("CommitPlugin: Adding final commit task to plan file", {
       conversationId: context.conversationId,
       behavior,
       planFilePath
@@ -7296,7 +7371,7 @@ var CommitPlugin = class {
         }
       }
       if (finalPhaseIndex === -1) {
-        logger22.warn(
+        logger14.warn(
           "CommitPlugin: Could not find final phase to add commit task"
         );
         return content;
@@ -7322,14 +7397,14 @@ var CommitPlugin = class {
         lines.splice(finalPhaseIndex + 1, 0, "", "### Tasks", commitTask);
       }
       const updatedContent = lines.join("\n");
-      logger22.info("CommitPlugin: Added final commit task to plan file", {
+      logger14.info("CommitPlugin: Added final commit task to plan file", {
         conversationId: context.conversationId,
         behavior,
         commitTask
       });
       return updatedContent;
     } catch (error) {
-      logger22.warn("CommitPlugin: Failed to add commit task to plan file", {
+      logger14.warn("CommitPlugin: Failed to add commit task to plan file", {
         error: error instanceof Error ? error.message : String(error),
         conversationId: context.conversationId
       });
@@ -7338,416 +7413,16 @@ var CommitPlugin = class {
   }
 };
 
-// src/components/beads/beads-plan-manager.ts
-import { writeFile as writeFile4, readFile as readFile4, access as access6 } from "fs/promises";
-import { dirname as dirname6 } from "path";
-import { mkdir as mkdir4 } from "fs/promises";
-var logger23 = createLogger("BeadsPlanManager");
-var BeadsPlanManager = class {
-  stateMachine = null;
-  /**
-   * Set the state machine definition for dynamic plan generation
-   */
-  setStateMachine(stateMachine) {
-    this.stateMachine = stateMachine;
-    logger23.debug("State machine set for beads plan manager", {
-      name: stateMachine.name,
-      phases: Object.keys(stateMachine.states)
-    });
-  }
-  /**
-   * Set the task backend configuration
-   */
-  setTaskBackend(taskBackend) {
-    logger23.debug("Task backend set for beads plan manager", {
-      backend: taskBackend.backend,
-      available: taskBackend.isAvailable
-    });
-  }
-  /**
-   * Get plan file information
-   */
-  async getPlanFileInfo(planFilePath) {
-    try {
-      await access6(planFilePath);
-      const content = await readFile4(planFilePath, "utf-8");
-      return {
-        path: planFilePath,
-        exists: true,
-        content
-      };
-    } catch (_error) {
-      return {
-        path: planFilePath,
-        exists: false
-      };
-    }
-  }
-  /**
-   * Create initial plan file if it doesn't exist
-   */
-  async ensurePlanFile(planFilePath, projectPath, gitBranch) {
-    logger23.debug("Ensuring beads plan file exists", {
-      planFilePath,
-      projectPath,
-      gitBranch
-    });
-    const planInfo = await this.getPlanFileInfo(planFilePath);
-    if (!planInfo.exists) {
-      logger23.info("Plan file not found, creating beads-optimized plan", {
-        planFilePath
-      });
-      await this.createInitialBeadsPlanFile(
-        planFilePath,
-        projectPath,
-        gitBranch
-      );
-      logger23.info("Beads plan file created successfully", { planFilePath });
-    } else {
-      logger23.debug("Plan file already exists", { planFilePath });
-    }
-  }
-  /**
-   * Create initial plan file optimized for beads workflow
-   */
-  async createInitialBeadsPlanFile(planFilePath, projectPath, gitBranch) {
-    logger23.debug("Creating beads-optimized plan file", { planFilePath });
-    try {
-      await mkdir4(dirname6(planFilePath), { recursive: true });
-      logger23.debug("Plan file directory ensured", {
-        directory: dirname6(planFilePath)
-      });
-      const projectName = getPathBasename(projectPath, "Unknown Project");
-      const branchInfo = gitBranch !== "no-git" ? ` (${gitBranch} branch)` : "";
-      const initialContent = this.generateBeadsInitialPlanContent(
-        projectName,
-        branchInfo
-      );
-      await writeFile4(planFilePath, initialContent, "utf-8");
-      logger23.info("Beads plan file written successfully", {
-        planFilePath,
-        contentLength: initialContent.length,
-        projectName
-      });
-    } catch (error) {
-      logger23.error("Failed to create beads plan file", error, {
-        planFilePath
-      });
-      throw error;
-    }
-  }
-  /**
-   * Generate initial plan file content optimized for beads workflow
-   */
-  generateBeadsInitialPlanContent(projectName, branchInfo) {
-    const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    if (!this.stateMachine) {
-      throw new Error(
-        "State machine not set. This should not happen as state machine is always loaded."
-      );
-    }
-    const phases = Object.keys(this.stateMachine.states);
-    const initialPhase = this.stateMachine.initial_state;
-    const documentationUrl = this.generateWorkflowDocumentationUrl(
-      this.stateMachine.name
-    );
-    let content = `# Development Plan: ${projectName}${branchInfo}
-
-*Generated on ${timestamp2} by Vibe Feature MCP*
-*Workflow: ${documentationUrl ? "[" + this.stateMachine.name + "](" + documentationUrl + ")" : this.stateMachine.name}*
-
-## Goal
-*Define what you're building or fixing - this will be updated as requirements are gathered*
-
-## ${this.capitalizePhase(initialPhase)}
-<!-- beads-phase-id: TBD -->
-### Tasks
-
-*Tasks managed via \`bd\` CLI*
-
-`;
-    for (const phase of phases) {
-      if (phase !== initialPhase) {
-        content += `## ${this.capitalizePhase(phase)}
-<!-- beads-phase-id: TBD -->
-### Tasks
-
-*Tasks managed via \`bd\` CLI*
-
-`;
-      }
-    }
-    content += `## Key Decisions
-*Important decisions will be documented here as they are made*
-
-## Notes
-*Additional context and observations*
-
----
-*This plan is maintained by the LLM and uses beads CLI for task management. Tool responses provide guidance on which bd commands to use for task management.*
-`;
-    return content;
-  }
-  /**
-   * Update plan file with new content
-   */
-  async updatePlanFile(planFilePath, content) {
-    await mkdir4(dirname6(planFilePath), { recursive: true });
-    await writeFile4(planFilePath, content, "utf-8");
-  }
-  /**
-   * Get plan file content for LLM context
-   */
-  async getPlanFileContent(planFilePath) {
-    const planInfo = await this.getPlanFileInfo(planFilePath);
-    if (!planInfo.exists) {
-      return "Plan file does not exist yet. It will be created when the LLM updates it.";
-    }
-    return planInfo.content || "";
-  }
-  /**
-   * Generate phase-specific plan file guidance optimized for beads
-   */
-  generatePlanFileGuidance(phase) {
-    if (!this.stateMachine) {
-      throw new Error(
-        "State machine not set. This should not happen as state machine is always loaded."
-      );
-    }
-    const phaseDefinition = this.stateMachine.states[phase];
-    if (!phaseDefinition) {
-      logger23.warn("Unknown phase for beads plan file guidance", { phase });
-      return `Track key decisions and take notes in the plan file. Use bd CLI for all task management.`;
-    }
-    return `Track key decisions and take notes in the plan file. Use bd CLI exclusively for task management - never use checkboxes. Document important decisions in the Key Decisions section.`;
-  }
-  /**
-   * Delete plan file
-   */
-  async deletePlanFile(planFilePath) {
-    logger23.debug("Deleting beads plan file", { planFilePath });
-    try {
-      await access6(planFilePath);
-      const { unlink: unlink2 } = await import("fs/promises");
-      await unlink2(planFilePath);
-      logger23.info("Beads plan file deleted successfully", { planFilePath });
-      return true;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        logger23.debug("Beads plan file does not exist, nothing to delete", {
-          planFilePath
-        });
-        return true;
-      }
-      logger23.error("Failed to delete beads plan file", error, {
-        planFilePath
-      });
-      throw error;
-    }
-  }
-  /**
-   * Ensure plan file is deleted (verify deletion)
-   */
-  async ensurePlanFileDeleted(planFilePath) {
-    logger23.debug("Ensuring beads plan file is deleted", { planFilePath });
-    try {
-      await access6(planFilePath);
-      logger23.warn("Beads plan file still exists after deletion attempt", {
-        planFilePath
-      });
-      return false;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        logger23.debug("Beads plan file successfully deleted (does not exist)", {
-          planFilePath
-        });
-        return true;
-      }
-      logger23.error("Error checking beads plan file deletion", error, {
-        planFilePath
-      });
-      throw error;
-    }
-  }
-  /**
-   * Capitalize phase name for display
-   */
-  capitalizePhase(phase) {
-    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
-  /**
-   * Generate workflow documentation URL for predefined workflows
-   */
-  generateWorkflowDocumentationUrl(workflowName) {
-    if (workflowName === "custom") {
-      return void 0;
-    }
-    return `https://mrsimpson.github.io/responsible-vibe-mcp/workflows/${workflowName}`;
-  }
-};
-
-// src/components/beads/beads-instruction-generator.ts
-var BeadsInstructionGenerator = class {
-  projectDocsManager;
-  constructor() {
-    this.projectDocsManager = new ProjectDocsManager();
-  }
-  /**
-   * Set the state machine definition (interface requirement)
-   */
-  setStateMachine(_stateMachine) {
-  }
-  /**
-   * Generate comprehensive instructions optimized for beads workflow
-   */
-  async generateInstructions(baseInstructions, context) {
-    const substitutedInstructions = this.applyVariableSubstitution(
-      baseInstructions,
-      context.conversationContext.projectPath,
-      context.conversationContext.gitBranch
-    );
-    const enhancedInstructions = await this.enhanceBeadsInstructions(
-      substitutedInstructions,
-      context
-    );
-    return {
-      instructions: enhancedInstructions,
-      planFileGuidance: "Using beads CLI for task management - plan file serves as context only",
-      metadata: {
-        phase: context.phase,
-        planFilePath: context.conversationContext.planFilePath,
-        transitionReason: context.transitionReason,
-        isModeled: context.isModeled
-      }
-    };
-  }
-  /**
-   * Apply variable substitution to instructions
-   */
-  applyVariableSubstitution(instructions, projectPath, gitBranch) {
-    const substitutions = this.projectDocsManager.getVariableSubstitutions(
-      projectPath,
-      gitBranch
-    );
-    let result = instructions;
-    for (const [variable, value] of Object.entries(substitutions)) {
-      result = result.replace(
-        new RegExp(this.escapeRegExp(variable), "g"),
-        value
-      );
-    }
-    return result;
-  }
-  /**
-   * Escape special regex characters in variable names
-   */
-  escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
-  /**
-   * Enhance instructions with beads-specific guidance
-   */
-  async enhanceBeadsInstructions(baseInstructions, context) {
-    const { planFileExists } = context;
-    const beadsTaskGuidance = await this.generateBeadsCLIGuidance(context);
-    let enhanced = `${baseInstructions}
-
-**Plan File Guidance:**
-Use the plan file as memory for the current objective
-- Update the "Key Decisions" section with important choices made
-- Add relevant notes to help maintain context
-- Do NOT enter tasks in the plan file, use beads CLI exclusively for task management
-
-${beadsTaskGuidance}`;
-    if (!planFileExists) {
-      enhanced += "\n\n**Note**: Plan file will be created when you first update it.";
-    }
-    enhanced += `
-
-**Important Reminders:**
-- Use ONLY bd CLI tool for task management - do not use your own task management tools
-- Call whats_next() after the next user message to maintain the development workflow`;
-    return enhanced;
-  }
-  /**
-   * Generate beads-specific task management guidance
-   */
-  async generateBeadsCLIGuidance(context) {
-    const { instructionSource } = context;
-    if (instructionSource === "whats_next") {
-      let additionalInstructions = `**bd Task Management:**
-      `;
-      const phaseTaskId = await this.extractPhaseTaskId(context);
-      if (!phaseTaskId) {
-        return additionalInstructions + `- Use bd CLI tool exclusively
-- **Start by listing ready tasks**: \`bd list --parent <phase-task-id> --status open\`
-- **Create new tasks**: \`bd create 'Task title' --parent <phase-task-id> -p <priority>\`
-- **Update status when working**: \`bd update <task-id> --status in_progress\`
-- **Complete tasks**: \`bd close <task-id>\`
-- **Focus on ready tasks first** - let beads handle dependencies
-- Add new tasks as they are identified during your work with the user`;
-      }
-      return additionalInstructions + `
-**Focus on subtasks of \`${phaseTaskId}\`**:
-\u2022 \`bd list --parent ${phaseTaskId} --status open\` - List ready work items
-\u2022 \`bd update <task-id> --status in_progress\` - Start working on a specific task
-\u2022 \`bd close <task-id>\` - Mark task complete when finished
-
-**New Tasks for Current Phase**:
-\u2022 \`bd create 'Task description' --parent ${phaseTaskId} -p <priority>\` - Create work item under current phase
-\u2022 \`bd dep add <task-id> <depends-on-id>\` - Define dependencies for a task:`;
-    }
-    return "";
-  }
-  async extractPhaseTaskId(context) {
-    try {
-      const { readFile: readFile6 } = await import("fs/promises");
-      const content = await readFile6(
-        context.conversationContext.planFilePath,
-        "utf-8"
-      );
-      const phaseName = this.capitalizePhase(context.phase);
-      const phaseHeader = `## ${phaseName}`;
-      const phaseSection = content.split("\n");
-      let foundPhaseHeader = false;
-      for (const line of phaseSection) {
-        if (line.trim() === phaseHeader) {
-          foundPhaseHeader = true;
-          continue;
-        }
-        if (foundPhaseHeader && line.includes("beads-phase-id:")) {
-          const match = line.match(/beads-phase-id:\s*([\w\d.-]+)/);
-          if (match) {
-            return match[1] || null;
-          }
-        }
-        if (foundPhaseHeader && line.startsWith("##") && line !== phaseHeader) {
-          break;
-        }
-      }
-      return null;
-    } catch (_error) {
-      return null;
-    }
-  }
-  /**
-   * Capitalize phase name for display
-   */
-  capitalizePhase(phase) {
-    return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-  }
-};
-
 // src/server-config.ts
-var logger24 = createLogger("ServerConfig");
+var logger15 = createLogger("ServerConfig");
 async function initializeServerComponents(config = {}) {
-  logger24.debug("Initializing server components", {
+  logger15.debug("Initializing server components", {
     config: JSON.stringify(config)
   });
   const projectPath = normalizeProjectPath(
     config.projectPath || process.env.PROJECT_PATH
   );
-  logger24.info("Using project path", {
+  logger15.info("Using project path", {
     projectPath,
     source: config.projectPath ? "config" : process.env.PROJECT_PATH ? "env" : "default"
   });
@@ -7764,11 +7439,11 @@ async function initializeServerComponents(config = {}) {
   );
   mcpServer.server.setRequestHandler(SetLevelRequestSchema, async (request) => {
     const level = request.params.level;
-    logger24.info("Setting logging level from MCP client", { level });
-    setMcpLoggingLevel(level);
+    logger15.info("Setting logging level from MCP client", { level });
+    setLoggingLevelFromString(level);
     return {};
   });
-  logger24.debug("Initializing core components");
+  logger15.debug("Initializing core components");
   const database = new FileStorage(
     path4.join(projectPath, ".vibe", "conversation.sqlite")
   );
@@ -7781,38 +7456,31 @@ async function initializeServerComponents(config = {}) {
   const transitionEngine = new TransitionEngine(projectPath);
   transitionEngine.setConversationManager(conversationManager);
   const taskBackendConfig = TaskBackendManager.detectTaskBackend();
-  const isBeadsBackend = taskBackendConfig.backend === "beads" && taskBackendConfig.isAvailable;
-  logger24.info("Task backend configuration", {
+  logger15.info("Task backend configuration", {
     backend: taskBackendConfig.backend,
     isAvailable: taskBackendConfig.isAvailable,
     autoDetected: !process.env["TASK_BACKEND"]
   });
-  const planManager = isBeadsBackend ? new BeadsPlanManager() : new PlanManager();
-  const instructionGenerator = isBeadsBackend ? new BeadsInstructionGenerator() : new InstructionGenerator(planManager);
+  const planManager = new PlanManager();
+  const instructionGenerator = new InstructionGenerator();
   const interactionLogger = new InteractionLogger(database);
   const pluginRegistry = new PluginRegistry();
-  if (process.env.COMMIT_BEHAVIOR) {
-    const commitPlugin = new CommitPlugin({ projectPath });
-    if (commitPlugin.isEnabled()) {
-      pluginRegistry.registerPlugin(commitPlugin);
-      logger24.info("CommitPlugin registered successfully", {
-        enabled: commitPlugin.isEnabled(),
-        sequence: commitPlugin.getSequence(),
-        behavior: process.env.COMMIT_BEHAVIOR
-      });
-    }
-  }
-  if (isBeadsBackend) {
-    const beadsPlugin = new BeadsPlugin({ projectPath });
-    if (beadsPlugin.isEnabled()) {
-      pluginRegistry.registerPlugin(beadsPlugin);
-      logger24.info("BeadsPlugin registered successfully", {
-        enabled: beadsPlugin.isEnabled(),
-        sequence: beadsPlugin.getSequence(),
-        autoDetected: !process.env["TASK_BACKEND"]
-      });
-    }
-  }
+  const commitPlugin = new CommitPlugin({ projectPath });
+  pluginRegistry.registerPlugin(commitPlugin);
+  logger15.info("CommitPlugin registered", {
+    enabled: commitPlugin.isEnabled(),
+    sequence: commitPlugin.getSequence(),
+    behavior: process.env.COMMIT_BEHAVIOR || "(not set)"
+  });
+  const beadsPlugin = new BeadsPlugin({ projectPath });
+  pluginRegistry.registerPlugin(beadsPlugin);
+  logger15.info("BeadsPlugin registered", {
+    enabled: beadsPlugin.isEnabled(),
+    sequence: beadsPlugin.getSequence(),
+    backend: taskBackendConfig.backend,
+    isAvailable: taskBackendConfig.isAvailable,
+    autoDetected: !process.env["TASK_BACKEND"]
+  });
   const context = {
     conversationManager,
     transitionEngine,
@@ -7825,7 +7493,7 @@ async function initializeServerComponents(config = {}) {
   };
   await database.initialize();
   workflowManager.loadProjectWorkflows(projectPath);
-  logger24.info("Server components initialized successfully");
+  logger15.info("Server components initialized successfully");
   return {
     mcpServer,
     database,
@@ -7848,7 +7516,7 @@ function createToolHandler(toolName, toolRegistry, responseRenderer, context) {
   };
 }
 async function registerMcpTools(mcpServer, toolRegistry, responseRenderer, context) {
-  logger24.debug("Registering MCP tools");
+  logger15.debug("Registering MCP tools");
   notificationService.setMcpServer(mcpServer);
   mcpServer.registerTool(
     "whats_next",
@@ -8048,7 +7716,7 @@ async function registerMcpTools(mcpServer, toolRegistry, responseRenderer, conte
   mcpServer.registerTool(
     "setup_project_docs",
     {
-      description: 'Create project documentation artifacts (architecture.md, requirements.md, design.md) using configurable templates OR by linking existing files via symlinks. **Linking existing documents Examples:**\n- `README.md` (project root)\n- `docs/architecture.md` (relative path)\n- `/absolute/path/to/requirements.txt`\n\n**Using "none" Option:**\n- Use `"none"` to create a placeholder that instructs LLM to use plan file instead\n- Useful when you prefer plan-file-only workflows\n\n**Mixed Usage Examples:**\n- `setup_project_docs({ architecture: "README.md", requirements: "none", design: "comprehensive" })`\n- `setup_project_docs({ architecture: "arc42", requirements: "ears", design: "none" })`',
+      description: "Create or link project docs (architecture.md, requirements.md, design.md). Use template names or file paths.",
       inputSchema: {
         architecture: z.string().default("freestyle").describe(
           `Architecture documentation: template name (${availableTemplates.architecture.join(", ")}, none) OR file path to existing document`
@@ -8095,12 +7763,12 @@ async function registerMcpTools(mcpServer, toolRegistry, responseRenderer, conte
     },
     createToolHandler("no_idea", toolRegistry, responseRenderer, context)
   );
-  logger24.info("MCP tools registered successfully", {
+  logger15.info("MCP tools registered successfully", {
     tools: toolRegistry.list()
   });
 }
 function registerMcpResources(mcpServer, resourceRegistry, responseRenderer, context) {
-  logger24.debug("Registering MCP resources");
+  logger15.debug("Registering MCP resources");
   mcpServer.resource(
     "Current Development Plan",
     "plan://current",
@@ -8233,7 +7901,7 @@ function registerMcpResources(mcpServer, resourceRegistry, responseRenderer, con
       };
     }
   );
-  logger24.info("MCP resources registered successfully", {
+  logger15.info("MCP resources registered successfully", {
     resources: ["plan://current", "state://current", "system-prompt://"],
     resourceTemplates: ["workflow://{name}"]
   });
@@ -8250,18 +7918,22 @@ var BaseToolHandler = class {
    */
   async handle(args, context) {
     const handlerName = this.constructor.name;
-    logHandlerExecution(handlerName, args);
+    if (context.loggerFactory) {
+      this.logger = context.loggerFactory(handlerName);
+    }
+    logHandlerExecution(handlerName, args, this.logger);
     const result = await safeExecute(
       () => this.executeHandler(args, context),
-      `${handlerName} execution failed`
+      `${handlerName} execution failed`,
+      this.logger
     );
     if (!result.success && result.error?.includes("CONVERSATION_NOT_FOUND")) {
       const availableWorkflows = context.workflowManager.getWorkflowNames();
       const helpfulError = createConversationNotFoundResult(availableWorkflows);
-      logHandlerCompletion(handlerName, helpfulError);
+      logHandlerCompletion(handlerName, helpfulError, this.logger);
       return helpfulError;
     }
-    logHandlerCompletion(handlerName, result);
+    logHandlerCompletion(handlerName, result, this.logger);
     return result;
   }
   /**
@@ -8397,6 +8069,12 @@ var WhatsNextHandler = class extends ConversationRequiredToolHandler {
     const planInfo = await context.planManager.getPlanFileInfo(
       conversationContext.planFilePath
     );
+    const stateMachine = context.workflowManager.loadWorkflowForProject(
+      conversationContext.projectPath,
+      conversationContext.workflowName
+    );
+    const phaseState = stateMachine.states[transitionResult.newPhase];
+    const allowedFilePatterns = phaseState?.allowed_file_patterns ?? ["**/*"];
     const instructions = await context.instructionGenerator.generateInstructions(
       transitionResult.instructions,
       {
@@ -8407,14 +8085,40 @@ var WhatsNextHandler = class extends ConversationRequiredToolHandler {
         },
         transitionReason: transitionResult.transitionReason,
         isModeled: transitionResult.isModeled,
-        planFileExists: planInfo.exists,
-        instructionSource: "whats_next"
+        instructionSource: "whats_next",
+        allowedFilePatterns
       }
     );
+    let finalInstructions = instructions.instructions;
+    if (context.pluginRegistry?.hasHook("afterInstructionsGenerated")) {
+      const hookContext = {
+        conversationId,
+        planFilePath: conversationContext.planFilePath,
+        currentPhase: transitionResult.newPhase,
+        workflow: conversationContext.workflowName,
+        projectPath: conversationContext.projectPath,
+        gitBranch: conversationContext.gitBranch,
+        planFileExists: planInfo.exists
+      };
+      const enriched = await context.pluginRegistry.executeHook(
+        "afterInstructionsGenerated",
+        hookContext,
+        {
+          instructions: instructions.instructions,
+          planFilePath: conversationContext.planFilePath,
+          phase: transitionResult.newPhase,
+          instructionSource: "whats_next"
+        }
+      );
+      if (enriched && typeof enriched === "object" && "instructions" in enriched) {
+        finalInstructions = enriched.instructions;
+      }
+    }
     const response = {
       phase: transitionResult.newPhase,
-      instructions: instructions.instructions,
-      plan_file_path: conversationContext.planFilePath
+      instructions: finalInstructions,
+      plan_file_path: conversationContext.planFilePath,
+      allowed_file_patterns: allowedFilePatterns
     };
     await this.logInteraction(
       context,
@@ -8459,8 +8163,6 @@ var WhatsNextHandler = class extends ConversationRequiredToolHandler {
     }
     return true;
   }
-  // Beads-specific instruction logic has been moved to BeadsInstructionGenerator strategy
-  // Utility methods moved to strategy implementations where needed
 };
 
 // src/tool-handlers/proceed-to-phase.ts
@@ -8494,6 +8196,9 @@ var ProceedToPhaseHandler = class extends ConversationRequiredToolHandler {
       conversationContext.projectPath,
       context
     );
+    const prePlanInfo = await context.planManager.getPlanFileInfo(
+      conversationContext.planFilePath
+    );
     const pluginContext = {
       conversationId,
       planFilePath: conversationContext.planFilePath,
@@ -8501,6 +8206,7 @@ var ProceedToPhaseHandler = class extends ConversationRequiredToolHandler {
       workflow: conversationContext.workflowName,
       projectPath: conversationContext.projectPath,
       gitBranch: conversationContext.gitBranch,
+      planFileExists: prePlanInfo.exists,
       targetPhase: target_phase
     };
     if (context.pluginRegistry) {
@@ -8535,6 +8241,12 @@ var ProceedToPhaseHandler = class extends ConversationRequiredToolHandler {
     const planInfo = await context.planManager.getPlanFileInfo(
       conversationContext.planFilePath
     );
+    const stateMachine = context.workflowManager.loadWorkflowForProject(
+      conversationContext.projectPath,
+      conversationContext.workflowName
+    );
+    const phaseState = stateMachine.states[transitionResult.newPhase];
+    const allowedFilePatterns = phaseState?.allowed_file_patterns ?? ["**/*"];
     const instructions = await context.instructionGenerator.generateInstructions(
       transitionResult.instructions,
       {
@@ -8545,20 +8257,42 @@ var ProceedToPhaseHandler = class extends ConversationRequiredToolHandler {
         },
         transitionReason: transitionResult.transitionReason,
         isModeled: transitionResult.isModeled,
-        planFileExists: planInfo.exists,
-        instructionSource: "proceed_to_phase"
+        instructionSource: "proceed_to_phase",
+        allowedFilePatterns
       }
     );
-    instructions.instructions += `
-
-    After transitioning to the ${transitionResult.newPhase} phase, check the already created tasks and add those that are missing based on the key decisions noted in the plan file.
-    While doing this, also denote dependencies for each task.
-    `;
+    let finalInstructions = instructions.instructions;
+    if (context.pluginRegistry?.hasHook("afterInstructionsGenerated")) {
+      const hookContext = {
+        conversationId,
+        planFilePath: conversationContext.planFilePath,
+        currentPhase: transitionResult.newPhase,
+        workflow: conversationContext.workflowName,
+        projectPath: conversationContext.projectPath,
+        gitBranch: conversationContext.gitBranch,
+        planFileExists: planInfo.exists
+      };
+      const enriched = await context.pluginRegistry.executeHook(
+        "afterInstructionsGenerated",
+        hookContext,
+        {
+          instructions: instructions.instructions,
+          planFilePath: conversationContext.planFilePath,
+          phase: transitionResult.newPhase,
+          instructionSource: "proceed_to_phase"
+        }
+      );
+      if (enriched && typeof enriched === "object" && "instructions" in enriched) {
+        finalInstructions = enriched.instructions;
+      }
+    }
+    finalInstructions += ` Review tasks for ${transitionResult.newPhase} phase, add missing ones based on key decisions.`;
     const response = {
       phase: transitionResult.newPhase,
-      instructions: instructions.instructions,
+      instructions: finalInstructions,
       plan_file_path: conversationContext.planFilePath,
-      transition_reason: transitionResult.transitionReason
+      transition_reason: transitionResult.transitionReason,
+      allowed_file_patterns: allowedFilePatterns
     };
     await this.logInteraction(
       context,
@@ -8725,23 +8459,17 @@ var ConductReviewHandler = class extends ConversationRequiredToolHandler {
    * Generate instructions for LLM to conduct guided review
    */
   async generateReviewInstructions(perspectives, currentPhase, targetPhase) {
-    const instructions = `Conduct a review of the ${currentPhase} phase before proceeding to ${targetPhase}.
+    const perspectiveDetails = perspectives.map(
+      (p, i) => `${i + 1}. **${p.perspective.toUpperCase()}**: ${p.prompt}`
+    ).join("\n");
+    const instructions = `Review ${currentPhase} phase before proceeding to ${targetPhase}.
 
-First, identify the artifacts and decisions from the ${currentPhase} phase by:
-1. Reviewing the plan file to see completed tasks and key decisions
-2. Using git status/diff to see what files were changed (if in a git repository)
-3. Analyzing recent conversation history for important decisions
+**Check:** plan file (tasks/decisions), git diff (changes), conversation history.
 
-Then, for each perspective below, analyze these artifacts and provide feedback:
+**Perspectives:**
+${perspectiveDetails}
 
-${perspectives.map(
-      (p, i) => `**${i + 1}. ${p.perspective.toUpperCase()} PERSPECTIVE:**
-${p.prompt}
-
-`
-    ).join("")}
-
-After completing all perspective reviews, summarize your findings and ask the user if they're ready to proceed to the ${targetPhase} phase.`;
+Summarize findings and ask user if ready to proceed.`;
     return {
       instructions,
       perspectives: perspectives.map((p) => ({
@@ -8755,18 +8483,21 @@ After completing all perspective reviews, summarize your findings and ask the us
 // src/tool-handlers/start-development.ts
 import { basename as basename4 } from "path";
 import { readFileSync, writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { resolve as resolve3 } from "path";
-var logger25 = createLogger("StartDevelopmentHandler");
 var StartDevelopmentHandler = class extends BaseToolHandler {
-  projectDocsManager;
-  constructor() {
-    super();
-    this.projectDocsManager = new ProjectDocsManager();
+  projectDocsManager = null;
+  getProjectDocsManager() {
+    if (!this.projectDocsManager) {
+      this.projectDocsManager = new ProjectDocsManager(this.logger);
+    }
+    return this.projectDocsManager;
   }
   async executeHandler(args, context) {
     validateRequiredArgs(args, ["workflow"]);
-    const taskBackendConfig = TaskBackendManager.validateTaskBackend();
+    const taskBackendConfig = TaskBackendManager.validateTaskBackend(
+      this.logger
+    );
     const selectedWorkflow = args.workflow;
     const requireReviews = args.require_reviews ?? false;
     const projectPath = stripVibePathSuffix(
@@ -8800,12 +8531,10 @@ var StartDevelopmentHandler = class extends BaseToolHandler {
       const suggestedBranchName = this.generateBranchSuggestion();
       const branchPromptResponse = {
         phase: "branch-prompt",
-        instructions: `You're currently on the ${currentBranch} branch. It's recommended to create a feature branch for development. Propose a branch creation by suggesting a branch command to the user call start_development again.
-
-Suggested command: \`git checkout -b ${suggestedBranchName}\`
-
-Please create a new branch and then call start_development again to begin development.`,
-        plan_file_path: ""
+        instructions: `On ${currentBranch}. Create feature branch: \`git checkout -b ${suggestedBranchName}\`, then retry \`start_development\`.`,
+        plan_file_path: "",
+        allowed_file_patterns: ["**/*"]
+        // Allow all files during branch prompt
       };
       this.logger.debug(
         "User on main/master branch, prompting for branch creation",
@@ -8863,6 +8592,8 @@ Please create a new branch and then call start_development again to begin develo
       workflow: selectedWorkflow,
       projectPath,
       gitBranch: conversationContext.gitBranch,
+      planFileExists: true,
+      // we just created/ensured the plan file exists
       stateMachine: {
         name: stateMachine.name,
         description: stateMachine.description,
@@ -8872,7 +8603,7 @@ Please create a new branch and then call start_development again to begin develo
     };
     if (context.pluginRegistry) {
       try {
-        const originalContent = await readFile5(
+        const originalContent = await readFile4(
           conversationContext.planFilePath,
           "utf-8"
         );
@@ -8883,14 +8614,14 @@ Please create a new branch and then call start_development again to begin develo
           originalContent
         );
         if (modifiedContent && modifiedContent !== originalContent) {
-          await writeFile5(
+          await writeFile4(
             conversationContext.planFilePath,
             modifiedContent,
             "utf-8"
           );
         }
       } catch (error) {
-        logger25.debug("Could not execute afterPlanFileCreated hook", {
+        this.logger.debug("Could not execute afterPlanFileCreated hook", {
           error: error instanceof Error ? error.message : String(error),
           planFilePath: conversationContext.planFilePath
         });
@@ -8915,30 +8646,33 @@ Please create a new branch and then call start_development again to begin develo
     }
     this.ensureGitignoreEntry(projectPath);
     const workflowDocumentationUrl = this.generateWorkflowDocumentationUrl(selectedWorkflow);
-    const baseInstructions = `Look at the plan file (${conversationContext.planFilePath}). Define entrance criteria for each phase of the workflow except the initial phase. Those criteria shall be based on the contents of the previous phase. 
-      Example: 
-      \`\`\`
-      ## Design
-
-      ### Phase Entrance Criteria:
-      - [ ] The requirements have been thoroughly defined.
-      - [ ] Alternatives have been evaluated and are documented. 
-      - [ ] It's clear what's in scope and out of scope
-      \`\`\`
-      
-      IMPORTANT: Once you added reasonable entrance call the whats_next() tool to get guided instructions for the next current phase.`;
-    const i18nGuidance = `
-
-NOTE: If the user is communicating in a non-English language, please translate the plan file content to that language while keeping the structure intact, and continue all interactions in the user's language.`;
-    const workflowDocumentationInfo = workflowDocumentationUrl ? `
-
-Inform the user about the chose workflow: He can visit: ${workflowDocumentationUrl} to get detailed information.` : "";
-    const finalInstructions = baseInstructions + workflowDocumentationInfo + i18nGuidance;
+    let finalInstructions = context.planManager.getInitialPlanGuidance(
+      conversationContext.planFilePath,
+      workflowDocumentationUrl
+    );
+    const phaseState = stateMachine.states[transitionResult.newPhase];
+    const allowedFilePatterns = phaseState?.allowed_file_patterns ?? ["**/*"];
+    if (context.pluginRegistry?.hasHook("afterInstructionsGenerated")) {
+      const enriched = await context.pluginRegistry.executeHook(
+        "afterInstructionsGenerated",
+        pluginContext,
+        {
+          instructions: finalInstructions,
+          planFilePath: conversationContext.planFilePath,
+          phase: transitionResult.newPhase,
+          instructionSource: "start_development"
+        }
+      );
+      if (enriched && typeof enriched === "object" && "instructions" in enriched) {
+        finalInstructions = enriched.instructions;
+      }
+    }
     const response = {
       phase: transitionResult.newPhase,
       instructions: finalInstructions,
       plan_file_path: conversationContext.planFilePath,
-      workflowDocumentationUrl
+      workflowDocumentationUrl,
+      allowed_file_patterns: allowedFilePatterns
     };
     await this.logInteraction(
       context,
@@ -8980,7 +8714,7 @@ Inform the user about the chose workflow: He can visit: ${workflowDocumentationU
         );
         return null;
       }
-      const docsInfo = await this.projectDocsManager.getProjectDocsInfo(projectPath);
+      const docsInfo = await this.getProjectDocsManager().getProjectDocsInfo(projectPath);
       const missingDocs = this.getMissingReferencedDocuments(
         referencedVariables,
         docsInfo,
@@ -8998,9 +8732,7 @@ Inform the user about the chose workflow: He can visit: ${workflowDocumentationU
       }
       const setupGuidance = await this.generateArtifactSetupGuidance(
         missingDocs,
-        workflowName,
-        docsInfo,
-        referencedVariables
+        workflowName
       );
       this.logger.info(
         "Missing required project artifacts detected for workflow that requires documentation",
@@ -9012,10 +8744,17 @@ Inform the user about the chose workflow: He can visit: ${workflowDocumentationU
           projectPath
         }
       );
+      const initialPhase = stateMachine.initial_state;
+      const initialPhaseState = stateMachine.states[initialPhase];
+      const allowedFilePatterns = initialPhaseState?.allowed_file_patterns ?? [
+        "**/*"
+      ];
       return {
         phase: "artifact-setup",
         instructions: setupGuidance,
-        plan_file_path: ""
+        plan_file_path: "",
+        // Use the initial phase's file restrictions during artifact setup
+        allowed_file_patterns: allowedFilePatterns
       };
     } catch (error) {
       this.logger.warn(
@@ -9032,7 +8771,7 @@ Inform the user about the chose workflow: He can visit: ${workflowDocumentationU
    * Analyze workflow content to detect document variable references
    */
   analyzeWorkflowDocumentReferences(stateMachine, projectPath) {
-    const variableSubstitutions = this.projectDocsManager.getVariableSubstitutions(projectPath);
+    const variableSubstitutions = this.getProjectDocsManager().getVariableSubstitutions(projectPath);
     const documentVariables = Object.keys(variableSubstitutions);
     const referencedVariables = /* @__PURE__ */ new Set();
     const workflowContent = JSON.stringify(stateMachine);
@@ -9053,7 +8792,10 @@ Inform the user about the chose workflow: He can visit: ${workflowDocumentationU
    */
   getMissingReferencedDocuments(referencedVariables, docsInfo, projectPath) {
     const missingDocs = [];
-    const variableSubstitutions = this.projectDocsManager.getVariableSubstitutions(projectPath, void 0);
+    const variableSubstitutions = this.getProjectDocsManager().getVariableSubstitutions(
+      projectPath,
+      void 0
+    );
     const variableToDocMap = {};
     for (const [variable, path6] of Object.entries(variableSubstitutions)) {
       const filename = basename4(path6);
@@ -9074,115 +8816,15 @@ Inform the user about the chose workflow: He can visit: ${workflowDocumentationU
   /**
    * Generate guidance for setting up missing project artifacts
    */
-  async generateArtifactSetupGuidance(missingDocs, workflowName, docsInfo, referencedVariables) {
-    const missingList = missingDocs.map((doc) => `- ${doc}`).join("\n");
-    const existingDocs = [];
-    if (docsInfo.architecture.exists) {
-      const fileName = basename4(docsInfo.architecture.path);
-      existingDocs.push(`\u2705 ${fileName}`);
-    }
-    if (docsInfo.requirements.exists) {
-      const fileName = basename4(docsInfo.requirements.path);
-      existingDocs.push(`\u2705 ${fileName}`);
-    }
-    if (docsInfo.design.exists) {
-      const fileName = basename4(docsInfo.design.path);
-      existingDocs.push(`\u2705 ${fileName}`);
-    }
-    const existingList = existingDocs.length > 0 ? `
-
-**Existing Documents:**
-${existingDocs.join("\n")}` : "";
-    const referencedVariablesList = referencedVariables.map((v) => `\`${v}\``).join(", ");
-    const availableTemplates = await this.projectDocsManager.templateManager.getAvailableTemplates();
-    const defaults = await this.projectDocsManager.templateManager.getDefaults();
-    const templateOptionsText = this.generateTemplateOptionsText(availableTemplates);
-    return `## Project Documentation Setup Required
+  async generateArtifactSetupGuidance(missingDocs, workflowName) {
+    const availableTemplates = await this.getProjectDocsManager().templateManager.getAvailableTemplates();
+    return `Missing docs for **${workflowName}**: ${missingDocs.join(", ")}
 
-The **${workflowName}** workflow references project documentation that doesn't exist yet.
+Run \`setup_project_docs()\` with templates: ${Object.entries(
+      availableTemplates
+    ).map(([type2, templates]) => `${type2}: ${templates.join("/")}`).join("; ")}
 
-**Referenced Variables:** ${referencedVariablesList}
-
-**Missing Documents:**
-${missingList}${existingList}
-
-## \u{1F680} **Quick Setup**
-
-Use the \`setup_project_docs\` tool to create these documents with templates:
-
-\`\`\`
-setup_project_docs({
-  architecture: "${defaults.architecture}",        // or other available options
-  requirements: "${defaults.requirements}",         // or other available options
-  design: "${defaults.design}"       // or other available options
-})
-\`\`\`
-
-${templateOptionsText}
-
-## \u26A1 **Next Steps**
-
-1. **Call \`setup_project_docs\`** with your preferred templates
-2. **Call \`start_development\`** again to begin the ${workflowName} workflow
-3. The workflow will reference these documents using the detected variables: ${referencedVariablesList}
-
-**Note:** You can also proceed without structured docs, but the workflow instructions will reference missing files.`;
-  }
-  /**
-   * Generate template options text dynamically
-   */
-  generateTemplateOptionsText(availableTemplates) {
-    const sections = [];
-    if (availableTemplates.architecture.length > 0) {
-      const archOptions = availableTemplates.architecture.map((template) => {
-        const description = this.getTemplateDescription(
-          template,
-          "architecture"
-        );
-        return `- **${template}**: ${description}`;
-      }).join("\n");
-      sections.push(`**Architecture Templates:**
-${archOptions}`);
-    }
-    if (availableTemplates.requirements.length > 0) {
-      const reqOptions = availableTemplates.requirements.map((template) => {
-        const description = this.getTemplateDescription(
-          template,
-          "requirements"
-        );
-        return `- **${template}**: ${description}`;
-      }).join("\n");
-      sections.push(`**Requirements Templates:**
-${reqOptions}`);
-    }
-    if (availableTemplates.design.length > 0) {
-      const designOptions = availableTemplates.design.map((template) => {
-        const description = this.getTemplateDescription(template, "design");
-        return `- **${template}**: ${description}`;
-      }).join("\n");
-      sections.push(`**Design Templates:**
-${designOptions}`);
-    }
-    return sections.length > 0 ? `## \u{1F4CB} **Template Options**
-
-${sections.join("\n\n")}` : "";
-  }
-  /**
-   * Get description for a template based on its name and type
-   */
-  getTemplateDescription(template, type2) {
-    switch (template) {
-      case "arc42":
-        return "Comprehensive software architecture template with diagrams";
-      case "ears":
-        return "WHEN...THEN format for clear, testable requirements";
-      case "comprehensive":
-        return "Full implementation guide with testing strategy";
-      case "freestyle":
-        return `Simple, flexible ${type2} documentation`;
-      default:
-        return `${template} format for ${type2} documentation`;
-    }
+Then retry \`start_development\`.`;
   }
   /**
    * Generate workflow documentation URL for predefined workflows
@@ -9544,12 +9186,12 @@ var ResetDevelopmentHandler = class extends BaseToolHandler {
 
 // src/tool-handlers/list-workflows.ts
 import { z as z2 } from "zod";
-var logger26 = createLogger("ListWorkflowsHandler");
+var logger16 = createLogger("ListWorkflowsHandler");
 var ListWorkflowsArgsSchema = z2.object({});
 var ListWorkflowsHandler = class extends BaseToolHandler {
   argsSchema = ListWorkflowsArgsSchema;
   async executeHandler(_args, context) {
-    logger26.info("Listing available workflows", {
+    logger16.info("Listing available workflows", {
       projectPath: context.projectPath
     });
     const availableWorkflows = context.workflowManager.getAvailableWorkflowsForProject(
@@ -9564,7 +9206,7 @@ var ListWorkflowsHandler = class extends BaseToolHandler {
     const response = {
       workflows
     };
-    logger26.info("Successfully listed workflows", {
+    logger16.info("Successfully listed workflows", {
       count: workflows.length,
       workflows: workflows.map((w) => w.name)
     });
@@ -9578,13 +9220,13 @@ import { z as z3 } from "zod";
 // src/version-info.ts
 import { execSync as execSync6 } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
-import { join as join8, dirname as dirname7 } from "path";
+import { join as join8, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-var logger27 = createLogger("VersionInfo");
+var logger17 = createLogger("VersionInfo");
 var BUILD_TIME_VERSION = null;
 function getVersionFromPackageJson() {
   try {
-    const currentDir = dirname7(fileURLToPath4(import.meta.url));
+    const currentDir = dirname6(fileURLToPath4(import.meta.url));
     const packageJsonPaths = [
       join8(currentDir, "..", "package.json"),
       join8(currentDir, "..", "..", "..", "package.json")
@@ -9593,7 +9235,7 @@ function getVersionFromPackageJson() {
       try {
         const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
         if (packageJson.version) {
-          logger27.debug("Found version in package.json", {
+          logger17.debug("Found version in package.json", {
             path: packageJsonPath,
             version: packageJson.version
           });
@@ -9603,7 +9245,7 @@ function getVersionFromPackageJson() {
           };
         }
       } catch (error) {
-        logger27.debug("Could not read package.json", {
+        logger17.debug("Could not read package.json", {
           path: packageJsonPath,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -9611,7 +9253,7 @@ function getVersionFromPackageJson() {
     }
     return null;
   } catch (error) {
-    logger27.debug("Error getting version from package.json", { error });
+    logger17.debug("Error getting version from package.json", { error });
     return null;
   }
 }
@@ -9621,7 +9263,7 @@ function getVersionFromGit() {
       encoding: "utf-8",
       stdio: "pipe"
     }).trim();
-    logger27.debug("Git describe output", { gitDescribe });
+    logger17.debug("Git describe output", { gitDescribe });
     const isDirty = gitDescribe.endsWith("-dirty");
     const cleanDescribe = isDirty ? gitDescribe.slice(0, -6) : gitDescribe;
     const parts = cleanDescribe.split("-");
@@ -9646,16 +9288,16 @@ function getVersionFromGit() {
       source: "git"
     };
   } catch (error) {
-    logger27.debug("Error getting version from git", {
+    logger17.debug("Error getting version from git", {
       error: error instanceof Error ? error.message : String(error)
     });
     return null;
   }
 }
 function getVersionInfo() {
-  logger27.debug("Determining version information");
+  logger17.debug("Determining version information");
   if (BUILD_TIME_VERSION) {
-    logger27.info("Using build-time version information", {
+    logger17.info("Using build-time version information", {
       version: BUILD_TIME_VERSION.version,
       source: BUILD_TIME_VERSION.source
     });
@@ -9665,7 +9307,7 @@ function getVersionInfo() {
   if (gitVersion) {
     const packageVersion2 = getVersionFromPackageJson();
     if (packageVersion2 && gitVersion.version === "unknown") {
-      logger27.info("Using package.json version with git commit info", {
+      logger17.info("Using package.json version with git commit info", {
         version: packageVersion2.version,
         commit: gitVersion.commit || "unknown",
         isDirty: String(gitVersion.isDirty || false)
@@ -9676,7 +9318,7 @@ function getVersionInfo() {
         source: "git"
       };
     }
-    logger27.info("Using git version information", {
+    logger17.info("Using git version information", {
       version: gitVersion.version,
       source: gitVersion.source,
       commit: gitVersion.commit || "none",
@@ -9686,13 +9328,13 @@ function getVersionInfo() {
   }
   const packageVersion = getVersionFromPackageJson();
   if (packageVersion) {
-    logger27.info("Using package.json version information", {
+    logger17.info("Using package.json version information", {
       version: packageVersion.version,
       source: packageVersion.source
     });
     return packageVersion;
   }
-  logger27.warn("Could not determine version information, using fallback");
+  logger17.warn("Could not determine version information, using fallback");
   return {
     version: "unknown",
     source: "fallback"
@@ -9711,14 +9353,14 @@ function getFormattedVersion() {
 }
 
 // src/tool-handlers/get-tool-info.ts
-var logger28 = createLogger("GetToolInfoHandler");
+var logger18 = createLogger("GetToolInfoHandler");
 var GetToolInfoArgsSchema = z3.object({
   // No input parameters needed
 });
 var GetToolInfoHandler = class extends BaseToolHandler {
   argsSchema = GetToolInfoArgsSchema;
   async executeHandler(_args, context) {
-    logger28.info("Generating comprehensive tool information", {
+    logger18.info("Generating comprehensive tool information", {
       projectPath: context.projectPath
     });
     const availableWorkflows = context.workflowManager.getAvailableWorkflowsForProject(
@@ -9808,7 +9450,7 @@ var GetToolInfoHandler = class extends BaseToolHandler {
         plan_file_path: conversationContext.planFilePath
       };
     } catch (error) {
-      logger28.debug("No active conversation found for workflow state", {
+      logger18.debug("No active conversation found for workflow state", {
         error
       });
     }
@@ -9835,7 +9477,7 @@ var GetToolInfoHandler = class extends BaseToolHandler {
     if (workflowState) {
       response.workflow_states = workflowState;
     }
-    logger28.info("Successfully generated tool information", {
+    logger18.info("Successfully generated tool information", {
       toolCount: tools.length,
       workflowCount: workflows.length,
       hasWorkflowState: !!workflowState
@@ -9855,22 +9497,25 @@ var GetToolInfoHandler = class extends BaseToolHandler {
 
 // src/tool-handlers/setup-project-docs.ts
 var SetupProjectDocsHandler = class extends BaseToolHandler {
-  projectDocsManager;
-  constructor() {
-    super();
-    this.projectDocsManager = new ProjectDocsManager();
+  projectDocsManager = null;
+  getProjectDocsManager() {
+    if (!this.projectDocsManager) {
+      this.projectDocsManager = new ProjectDocsManager(this.logger);
+    }
+    return this.projectDocsManager;
   }
   async executeHandler(args, context) {
     const projectPath = stripVibePathSuffix(
       args.project_path,
       context.projectPath || process.cwd()
     );
+    const projectDocsManager = this.getProjectDocsManager();
     this.logger.info(
       "Setting up project docs with enhanced file linking support",
       { args, projectPath }
     );
     try {
-      const availableTemplates = await this.projectDocsManager.templateManager.getAvailableTemplates();
+      const availableTemplates = await projectDocsManager.templateManager.getAvailableTemplates();
       const processedArgs = await this.validateAndProcessArgs(
         args,
         availableTemplates,
@@ -9882,7 +9527,7 @@ var SetupProjectDocsHandler = class extends BaseToolHandler {
           created: [],
           linked: [],
           skipped: [],
-          paths: this.projectDocsManager.getDocumentPaths(projectPath),
+          paths: projectDocsManager.getDocumentPaths(projectPath),
           message: processedArgs.error || "Unknown error during validation"
         };
       }
@@ -9891,12 +9536,12 @@ var SetupProjectDocsHandler = class extends BaseToolHandler {
           "Invalid processed args: missing templateOptions or filePaths"
         );
       }
-      const result = await this.projectDocsManager.createOrLinkProjectDocs(
+      const result = await projectDocsManager.createOrLinkProjectDocs(
         projectPath,
         processedArgs.templateOptions,
         processedArgs.filePaths
       );
-      const paths = this.projectDocsManager.getDocumentPaths(projectPath);
+      const paths = projectDocsManager.getDocumentPaths(projectPath);
       let message = "Project documentation setup completed.";
       if (result.created.length > 0) {
         message += ` Created: ${result.created.join(", ")}.`;
@@ -9931,7 +9576,7 @@ var SetupProjectDocsHandler = class extends BaseToolHandler {
         created: [],
         linked: [],
         skipped: [],
-        paths: this.projectDocsManager.getDocumentPaths(projectPath),
+        paths: projectDocsManager.getDocumentPaths(projectPath),
         message: `Failed to setup project docs: ${error instanceof Error ? error.message : "Unknown error"}`
       };
     }
@@ -10009,11 +9654,11 @@ var NoIdeaHandler = class extends BaseToolHandler {
 };
 
 // src/tool-handlers/index.ts
-var logger29 = createLogger("ToolRegistry");
+var logger19 = createLogger("ToolRegistry");
 var DefaultToolRegistry = class {
   handlers = /* @__PURE__ */ new Map();
   register(name, handler) {
-    logger29.debug("Registering tool handler", {
+    logger19.debug("Registering tool handler", {
       name,
       handlerType: handler.constructor.name
     });
@@ -10038,17 +9683,24 @@ function createToolRegistry() {
   registry.register("get_tool_info", new GetToolInfoHandler());
   registry.register("setup_project_docs", new SetupProjectDocsHandler());
   registry.register("no_idea", new NoIdeaHandler());
-  logger29.info("Tool registry created with handlers", {
+  logger19.info("Tool registry created with handlers", {
     handlers: registry.list()
   });
   return registry;
 }
 
 // src/resource-handlers/development-plan.ts
-var logger30 = createLogger("DevelopmentPlanResourceHandler");
+var defaultLogger8 = createLogger("DevelopmentPlanResourceHandler");
 var DevelopmentPlanResourceHandler = class {
+  logger;
+  constructor(logger24) {
+    this.logger = logger24 ?? defaultLogger8;
+  }
   async handle(uri, context) {
-    logger30.debug("Processing development plan resource request", {
+    if (context.loggerFactory) {
+      this.logger = context.loggerFactory("DevelopmentPlanResourceHandler");
+    }
+    this.logger.debug("Processing development plan resource request", {
       uri: uri.href
     });
     return safeExecute(async () => {
@@ -10066,10 +9718,17 @@ var DevelopmentPlanResourceHandler = class {
 };
 
 // src/resource-handlers/conversation-state.ts
-var logger31 = createLogger("ConversationStateResourceHandler");
+var defaultLogger9 = createLogger("ConversationStateResourceHandler");
 var ConversationStateResourceHandler = class {
+  logger;
+  constructor(logger24) {
+    this.logger = logger24 ?? defaultLogger9;
+  }
   async handle(uri, context) {
-    logger31.debug("Processing conversation state resource request", {
+    if (context.loggerFactory) {
+      this.logger = context.loggerFactory("ConversationStateResourceHandler");
+    }
+    this.logger.debug("Processing conversation state resource request", {
       uri: uri.href
     });
     return safeExecute(async () => {
@@ -10096,10 +9755,19 @@ var ConversationStateResourceHandler = class {
 import fs5 from "fs";
 import path5 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-var logger32 = createLogger("WorkflowResourceHandler");
+var defaultLogger10 = createLogger("WorkflowResourceHandler");
 var WorkflowResourceHandler = class {
+  logger;
+  constructor(logger24) {
+    this.logger = logger24 ?? defaultLogger10;
+  }
   async handle(uri, context) {
-    logger32.debug("Processing workflow resource request", { uri: uri.href });
+    if (context.loggerFactory) {
+      this.logger = context.loggerFactory("WorkflowResourceHandler");
+    }
+    this.logger.debug("Processing workflow resource request", {
+      uri: uri.href
+    });
     return safeExecute(async () => {
       const workflowName = uri.hostname;
       if (!workflowName) {
@@ -10107,7 +9775,10 @@ var WorkflowResourceHandler = class {
           "Invalid workflow URI: missing workflow name. Expected: workflow://workflow-name"
         );
       }
-      logger32.info("Loading workflow resource", { workflowName, uri: uri.href });
+      this.logger.info("Loading workflow resource", {
+        workflowName,
+        uri: uri.href
+      });
       let yamlContent;
       let filePath;
       const workflow = context.workflowManager.getWorkflow(workflowName);
@@ -10137,7 +9808,7 @@ var WorkflowResourceHandler = class {
           `${workflowName}.yml`
         );
         if (!fs5.existsSync(workflowFileYml)) {
-          logger32.error(
+          this.logger.error(
             "Workflow file not found",
             new Error(`Workflow '${workflowName}' not found`),
             {
@@ -10161,7 +9832,7 @@ var WorkflowResourceHandler = class {
         filePath = workflowFile;
       }
       yamlContent = fs5.readFileSync(filePath, "utf-8");
-      logger32.info("Successfully loaded workflow resource", {
+      this.logger.info("Successfully loaded workflow resource", {
         workflowName,
         filePath,
         contentLength: yamlContent.length
@@ -10176,17 +9847,24 @@ var WorkflowResourceHandler = class {
 };
 
 // src/resource-handlers/system-prompt.ts
-var logger33 = createLogger("SystemPromptResourceHandler");
+var defaultLogger11 = createLogger("SystemPromptResourceHandler");
 var SystemPromptResourceHandler = class {
-  async handle(uri, _context) {
-    logger33.debug("Processing system prompt resource request", {
+  logger;
+  constructor(logger24) {
+    this.logger = logger24 ?? defaultLogger11;
+  }
+  async handle(uri, context) {
+    if (context.loggerFactory) {
+      this.logger = context.loggerFactory("SystemPromptResourceHandler");
+    }
+    this.logger.debug("Processing system prompt resource request", {
       uri: uri.href
     });
     return safeExecute(async () => {
       const loader2 = new StateMachineLoader();
       const stateMachine = loader2.loadStateMachine(process.cwd());
       const systemPrompt = generateSystemPrompt(stateMachine);
-      logger33.debug("Generated system prompt for resource", {
+      this.logger.debug("Generated system prompt for resource", {
         promptLength: systemPrompt.length,
         workflowName: stateMachine.name
       });
@@ -10200,11 +9878,11 @@ var SystemPromptResourceHandler = class {
 };
 
 // src/resource-handlers/index.ts
-var logger34 = createLogger("ResourceRegistry");
+var logger20 = createLogger("ResourceRegistry");
 var DefaultResourceRegistry = class {
   handlers = /* @__PURE__ */ new Map();
   register(pattern, handler) {
-    logger34.debug("Registering resource handler", {
+    logger20.debug("Registering resource handler", {
       pattern,
       handlerType: handler.constructor.name
     });
@@ -10213,11 +9891,11 @@ var DefaultResourceRegistry = class {
   resolve(uri) {
     for (const [pattern, handler] of this.handlers.entries()) {
       if (uri.includes(pattern)) {
-        logger34.debug("Resolved resource handler", { uri, pattern });
+        logger20.debug("Resolved resource handler", { uri, pattern });
         return handler;
       }
     }
-    logger34.debug("No resource handler found for URI", { uri });
+    logger20.debug("No resource handler found for URI", { uri });
     return void 0;
   }
 };
@@ -10227,7 +9905,7 @@ function createResourceRegistry() {
   registry.register("state://current", new ConversationStateResourceHandler());
   registry.register("workflow://", new WorkflowResourceHandler());
   registry.register("system-prompt://", new SystemPromptResourceHandler());
-  logger34.info("Resource registry created with handlers", {
+  logger20.info("Resource registry created with handlers", {
     patterns: [
       "plan://current",
       "state://current",
@@ -10239,13 +9917,13 @@ function createResourceRegistry() {
 }
 
 // src/response-renderer.ts
-var logger35 = createLogger("ResponseRenderer");
+var logger21 = createLogger("ResponseRenderer");
 var DefaultResponseRenderer = class {
   /**
    * Render a tool handler result as an MCP tool response
    */
   renderToolResponse(result) {
-    logger35.debug("Rendering tool response", {
+    logger21.debug("Rendering tool response", {
       success: result.success,
       hasData: !!result.data,
       hasError: !!result.error
@@ -10267,7 +9945,7 @@ var DefaultResponseRenderer = class {
    * Render a resource handler result as an MCP resource response
    */
   renderResourceResponse(result) {
-    logger35.debug("Rendering resource response", {
+    logger21.debug("Rendering resource response", {
       success: result.success,
       hasData: !!result.data
     });
@@ -10298,7 +9976,7 @@ var DefaultResponseRenderer = class {
    */
   renderError(error) {
     const errorMessage = error instanceof Error ? error.message : error;
-    logger35.debug("Rendering error response", { errorMessage });
+    logger21.debug("Rendering error response", { errorMessage });
     return {
       content: [
         {
@@ -10314,8 +9992,53 @@ function createResponseRenderer() {
   return new DefaultResponseRenderer();
 }
 
+// src/mcp-log-sink.ts
+function capitalizePhase2(phase) {
+  return phase.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function createMcpLogSink(mcpServer) {
+  return {
+    async log(level, logger24, message, context) {
+      try {
+        let enhancedMessage = message;
+        let notificationLevel = level;
+        if (context && (context["from"] || context["to"]) && message.includes("transition")) {
+          const from = context["from"] ? capitalizePhase2(context["from"]) : "";
+          const to = context["to"] ? capitalizePhase2(context["to"]) : "";
+          if (from && to) {
+            enhancedMessage = `Phase Transition: ${from} \u2192 ${to}`;
+            notificationLevel = "info";
+          }
+        }
+        if (message.includes("initialized successfully")) {
+          enhancedMessage = "\u{1F680} Vibe Feature MCP Server Ready";
+          notificationLevel = "info";
+        }
+        let logData = enhancedMessage;
+        if (context) {
+          try {
+            const contextStr = JSON.stringify(context, null, 0);
+            logData = `${enhancedMessage} ${contextStr}`;
+          } catch (_error) {
+            logData = `${enhancedMessage} [context serialization failed]`;
+          }
+        }
+        await mcpServer.server.notification({
+          method: "notifications/message",
+          params: {
+            level: notificationLevel,
+            logger: logger24,
+            data: logData
+          }
+        });
+      } catch (_error) {
+      }
+    }
+  };
+}
+
 // src/server-implementation.ts
-var logger36 = createLogger("ResponsibleVibeMCPServer");
+var logger22 = createLogger("ResponsibleVibeMCPServer");
 async function createResponsibleVibeMCPServer(config = {}) {
   const components = await initializeServerComponents(config);
   return new ResponsibleVibeMCPServer(config, components);
@@ -10324,7 +10047,7 @@ var ResponsibleVibeMCPServer = class {
   constructor(config, serverComponents) {
     this.config = config;
     this.serverComponents = serverComponents;
-    logger36.debug("ResponsibleVibeMCPServer created", {
+    logger22.debug("ResponsibleVibeMCPServer created", {
       config: JSON.stringify(this.config)
     });
   }
@@ -10333,7 +10056,7 @@ var ResponsibleVibeMCPServer = class {
    * Initialize the server and all its components
    */
   async initialize() {
-    logger36.debug("Initializing ResponsibleVibeMCPServer");
+    logger22.debug("Initializing ResponsibleVibeMCPServer");
     try {
       this.components = this.serverComponents;
       const toolRegistry = createToolRegistry();
@@ -10342,7 +10065,7 @@ var ResponsibleVibeMCPServer = class {
       this.components.toolRegistry = toolRegistry;
       this.components.resourceRegistry = resourceRegistry;
       this.components.responseRenderer = responseRenderer;
-      setMcpServerForLogging(this.components.mcpServer);
+      registerLogSink(createMcpLogSink(this.components.mcpServer));
       await registerMcpTools(
         this.components.mcpServer,
         toolRegistry,
@@ -10356,7 +10079,7 @@ var ResponsibleVibeMCPServer = class {
         this.components.context
       );
     } catch (error) {
-      logger36.error(
+      logger22.error(
         "Failed to initialize ResponsibleVibeMCPServer",
         error
       );
@@ -10489,16 +10212,16 @@ var ResponsibleVibeMCPServer = class {
    * Cleanup server resources
    */
   async cleanup() {
-    logger36.debug("Cleaning up server resources");
+    logger22.debug("Cleaning up server resources");
     if (this.components?.database) {
       await this.components.database.close();
     }
-    logger36.info("Server cleanup completed");
+    logger22.info("Server cleanup completed");
   }
 };
 
 // src/index.ts
-var logger37 = createLogger("Main");
+var logger23 = createLogger("Main");
 function parseCliArgs() {
   return { shouldStartServer: true };
 }
@@ -10516,30 +10239,46 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.getMcpServer().connect(transport);
     process.on("SIGINT", async () => {
-      logger37.info("Shutting down Vibe Feature MCP Server...");
+      logger23.info("Shutting down Vibe Feature MCP Server...");
       await server.cleanup();
       process.exit(0);
     });
     process.on("SIGTERM", async () => {
-      logger37.info("Shutting down Vibe Feature MCP Server...");
+      logger23.info("Shutting down Vibe Feature MCP Server...");
       await server.cleanup();
       process.exit(0);
     });
   } catch (error) {
-    logger37.error("Failed to start server", error);
+    logger23.error("Failed to start server", error);
     process.exit(1);
   }
 }
 var isMainModule = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("ade-workflows-server") || process.argv[1]?.endsWith("index.js");
 if (isMainModule) {
   await main().catch((error) => {
-    logger37.error("Unhandled error in main", error);
+    logger23.error("Unhandled error in main", error);
     process.exit(1);
   });
 }
 export {
+  BaseToolHandler,
+  BeadsPlugin,
+  ConductReviewHandler,
+  ConversationRequiredToolHandler,
+  DefaultToolRegistry,
+  GetToolInfoHandler,
+  ListWorkflowsHandler,
+  NoIdeaHandler,
+  PluginRegistry,
+  ProceedToPhaseHandler,
+  ResetDevelopmentHandler,
   ResponsibleVibeMCPServer,
+  ResumeWorkflowHandler,
+  SetupProjectDocsHandler,
+  StartDevelopmentHandler,
+  WhatsNextHandler,
   createResponsibleVibeMCPServer,
+  createToolRegistry,
   main as startMcpServer
 };
 /*! Bundled license information: