@codemcp/workflows 6.4.0 → 6.5.1

package/packages/cli/dist/{chunk-D2Q6Y3QQ.js → chunk-4AZGS2GG.js}

@@ -2864,25 +2864,27 @@ 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 clearLogSink() {
+  logSinkInstance = null;
+}
+function setLoggingLevel(level) {
+  currentLoggingLevel = level;
 }
-function setMcpLoggingLevel(level) {
+function setLoggingLevelFromString(level) {
   const levelMap = {
     debug: LogLevel.DEBUG,
     info: LogLevel.INFO,
@@ -2922,7 +2924,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;
@@ -2947,31 +2949,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}
 `);
         }
       }
@@ -2979,85 +2965,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(() => {
       });
     }
   }
@@ -3068,7 +3011,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");
@@ -3294,6 +3237,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
@@ -3375,13 +3347,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/
@@ -3754,16 +3734,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, logger14 = defaultLogger) {
     this.workflowManager = new WorkflowManager();
-    logger5.info("TransitionEngine initialized", { projectPath });
+    this.logger = logger14;
+    this.logger.info("TransitionEngine initialized", { projectPath });
   }
   /**
    * Set the conversation manager (dependency injection)
@@ -3782,11 +3767,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
@@ -3796,51 +3781,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);
@@ -3863,19 +3815,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,
@@ -3884,14 +3834,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
@@ -3900,8 +3850,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
     });
@@ -3917,7 +3867,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,
@@ -3928,7 +3878,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];
@@ -3939,7 +3889,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,
@@ -3952,12 +3902,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
@@ -3973,7 +3917,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;
@@ -3991,11 +3935,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;
     }
   }
@@ -4045,12 +3989,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;
@@ -4070,7 +4014,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
       });
@@ -4102,7 +4046,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;
     }
   }
@@ -4114,13 +4058,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;
@@ -4137,12 +4081,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
       });
@@ -4164,7 +4108,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
           });
         }
@@ -4174,7 +4118,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;
@@ -4194,12 +4138,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
       });
@@ -4218,13 +4162,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");
   }
 };
 
@@ -4236,7 +4180,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
@@ -4264,7 +4208,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
       });
@@ -4274,7 +4218,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
       });
@@ -4304,7 +4248,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(),
@@ -4316,7 +4260,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
       });
@@ -4431,7 +4375,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;
   /**
@@ -4439,7 +4383,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)
     });
@@ -4448,7 +4392,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
     });
@@ -4476,43 +4420,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;
@@ -4544,7 +4488,7 @@ var PlanManager = class {
 *Additional context and observations*
 
 `;
-    content += `## ${this.capitalizePhase(initialPhase)}
+    content += `## ${capitalizePhase(initialPhase)}
 ### Tasks
 - [ ] *Tasks will be added as they are identified*
 
@@ -4554,7 +4498,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*
 
@@ -4606,31 +4550,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;
@@ -4640,32 +4584,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
@@ -4676,10 +4614,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;
@@ -4706,11 +4658,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
@@ -4739,7 +4691,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
@@ -4749,14 +4701,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 {
@@ -4785,7 +4737,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}`);
@@ -4796,7 +4748,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
     });
@@ -4809,7 +4761,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
@@ -4833,7 +4785,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
@@ -4876,7 +4828,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";
@@ -4887,10 +4839,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";
@@ -4904,13 +4856,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;
@@ -4920,24 +4872,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
@@ -4949,7 +4901,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
@@ -4969,7 +4921,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) {
@@ -4980,9 +4932,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;
     }
   }
@@ -4990,13 +4942,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;
@@ -5009,7 +4961,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() {
@@ -5038,13 +4990,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
     });
@@ -5098,7 +5050,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)`);
     }
   }
@@ -5179,16 +5131,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;
     }
   }
@@ -5197,12 +5149,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(logger14 = defaultLogger2) {
     this.templateManager = new TemplateManager();
+    this.logger = logger14;
   }
   /**
    * Get project docs directory path
@@ -5373,7 +5327,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,
@@ -5392,13 +5346,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
       });
@@ -5412,14 +5366,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
         });
@@ -5441,9 +5395,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
       });
@@ -5514,7 +5468,7 @@ 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");
 var FileDetectionManager = class {
   projectPath;
   constructor(projectPath) {
@@ -5524,7 +5478,7 @@ var FileDetectionManager = class {
    * Detect existing documentation files in the project
    */
   async detectDocumentationFiles() {
-    logger12.debug("Starting documentation file detection", {
+    logger10.debug("Starting documentation file detection", {
       projectPath: this.projectPath
     });
     const searchLocations = this.getSearchLocations();
@@ -5550,7 +5504,7 @@ var FileDetectionManager = class {
           }
         }
       } catch (error) {
-        logger12.debug("Search location not accessible", {
+        logger10.debug("Search location not accessible", {
           location,
           error: error instanceof Error ? error.message : "Unknown error"
         });
@@ -5559,7 +5513,7 @@ var FileDetectionManager = class {
     result.architecture = this.sortAndDeduplicate(result.architecture);
     result.requirements = this.sortAndDeduplicate(result.requirements);
     result.design = this.sortAndDeduplicate(result.design);
-    logger12.info("Documentation file detection completed", {
+    logger10.info("Documentation file detection completed", {
       found: {
         architecture: result.architecture.length,
         requirements: result.requirements.length,
@@ -5604,7 +5558,7 @@ var FileDetectionManager = class {
       }
       return files;
     } catch (error) {
-      logger12.debug("Failed to scan location", {
+      logger10.debug("Failed to scan location", {
         location,
         error: error instanceof Error ? error.message : "Unknown error"
       });
@@ -5681,43 +5635,27 @@ var FileDetectionManager = class {
    * Format file suggestions for LLM responses
    */
   formatSuggestions(detectionResult) {
-    const suggestions = [];
+    const found = [];
     if (detectionResult.architecture.length > 0) {
-      suggestions.push(`**Architecture files found:**`);
-      for (const file of detectionResult.architecture.slice(0, 3)) {
-        suggestions.push(`  - ${file.relativePath} (${file.confidence} confidence)`);
-      }
+      found.push(`architecture: ${detectionResult.architecture.slice(0, 2).map((f) => f.relativePath).join(", ")}`);
     }
     if (detectionResult.requirements.length > 0) {
-      suggestions.push(`**Requirements files found:**`);
-      for (const file of detectionResult.requirements.slice(0, 3)) {
-        suggestions.push(`  - ${file.relativePath} (${file.confidence} confidence)`);
-      }
+      found.push(`requirements: ${detectionResult.requirements.slice(0, 2).map((f) => f.relativePath).join(", ")}`);
     }
     if (detectionResult.design.length > 0) {
-      suggestions.push(`**Design files found:**`);
-      for (const file of detectionResult.design.slice(0, 3)) {
-        suggestions.push(`  - ${file.relativePath} (${file.confidence} confidence)`);
-      }
+      found.push(`design: ${detectionResult.design.slice(0, 2).map((f) => f.relativePath).join(", ")}`);
     }
-    if (suggestions.length === 0) {
+    if (found.length === 0) {
       return "No existing documentation files detected.";
     }
-    return [
-      "Existing documentation files detected:",
-      "",
-      ...suggestions,
-      "",
-      "You can use these files with `setup_project_docs` by providing the file paths instead of template names.",
-      'Example: `setup_project_docs({ architecture: "README.md", requirements: "docs/requirements.md", design: "freestyle" })`'
-    ].join("\n");
+    return `Found: ${found.join("; ")}. Link existing files via \`setup_project_docs({ architecture: "path/to/file.md" })\` or use template names.`;
   }
 };
 
 // ../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
@@ -5731,7 +5669,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";
@@ -5741,10 +5679,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";
@@ -5765,7 +5703,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;
     }
   }
@@ -5775,7 +5713,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 .", {
@@ -5788,10 +5726,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)
@@ -5805,7 +5743,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;
@@ -5816,13 +5754,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)
       });
@@ -5833,7 +5771,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
@@ -5845,8 +5783,9 @@ 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(logger14 = 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", {
@@ -5854,9 +5793,9 @@ var TaskBackendManager = class _TaskBackendManager {
       });
     }
     if (!envBackend || !["markdown", "beads"].includes(envBackend)) {
-      const beadsAvailable2 = _TaskBackendManager.checkBeadsAvailability();
+      const beadsAvailable2 = _TaskBackendManager.checkBeadsAvailability(logger14);
       if (beadsAvailable2.isAvailable) {
-        logger14.info("Auto-detected beads backend (bd command available)", {
+        logger14.debug("Auto-detected beads backend (bd command available)", {
           reason: "TASK_BACKEND not set, bd command found"
         });
         return {
@@ -5880,7 +5819,7 @@ var TaskBackendManager = class _TaskBackendManager {
         isAvailable: true
       };
     }
-    const beadsAvailable = _TaskBackendManager.checkBeadsAvailability();
+    const beadsAvailable = _TaskBackendManager.checkBeadsAvailability(logger14);
     if (beadsAvailable.isAvailable) {
       logger14.debug("Using explicitly configured beads backend");
       return {
@@ -5897,7 +5836,7 @@ var TaskBackendManager = class _TaskBackendManager {
   /**
    * Check if beads command is available and functional
    */
-  static checkBeadsAvailability() {
+  static checkBeadsAvailability(logger14 = defaultLogger3) {
     try {
       const output = execSync3("bd --version", {
         encoding: "utf-8",
@@ -5973,9 +5912,10 @@ export TASK_BACKEND=markdown
   }
   /**
    * Validate task backend configuration and throw error if invalid
+   *
    */
-  static validateTaskBackend() {
-    const config = this.detectTaskBackend();
+  static validateTaskBackend(logger14 = defaultLogger3) {
+    const config = this.detectTaskBackend(logger14);
     if (!config.isAvailable) {
       const setupInstructions = config.backend === "beads" ? this.getBeadsSetupInstructions() : "Task backend validation failed";
       throw new Error(`Task backend '${config.backend}' is not available.
@@ -5994,11 +5934,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, logger14 = defaultLogger4) {
     this.projectPath = projectPath;
+    this.logger = logger14;
   }
   /**
    * Ensure beads is initialized in the project directory
@@ -6014,7 +5956,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 {
@@ -6023,12 +5965,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 {
@@ -6046,7 +5988,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,
@@ -6060,7 +6002,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
@@ -6068,7 +6010,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
@@ -6082,10 +6024,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
         });
@@ -6101,12 +6043,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,
@@ -6120,7 +6062,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
@@ -6133,7 +6075,7 @@ var BeadsIntegration = class {
           phaseName: phaseTitle,
           taskId: phaseTaskId
         });
-        logger15.debug("Created beads phase task", {
+        this.logger.debug("Created beads phase task", {
           phase,
           phaseTaskId,
           epicId,
@@ -6147,10 +6089,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
           });
@@ -6158,7 +6100,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
@@ -6171,13 +6113,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
     });
@@ -6186,7 +6128,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,
@@ -6200,7 +6142,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,
@@ -6214,14 +6156,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,
@@ -6230,7 +6172,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
@@ -6244,25 +6186,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
    */
@@ -6310,11 +6246,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, logger14 = defaultLogger5) {
     this.projectPath = projectPath;
+    this.logger = logger14;
   }
   /**
    * Get the path to the beads state file for a conversation
@@ -6335,7 +6273,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,
@@ -6352,7 +6290,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,
@@ -6361,14 +6299,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,
@@ -6387,7 +6325,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,
@@ -6395,7 +6333,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),
@@ -6409,7 +6347,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
       });
@@ -6423,7 +6361,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
@@ -6438,21 +6376,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,
@@ -6482,7 +6420,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,
@@ -6490,7 +6428,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
@@ -6501,7 +6439,7 @@ var BeadsStateManager = class {
 };
 
 // ../core/dist/interaction-logger.js
-var logger17 = createLogger("InteractionLogger");
+var logger12 = createLogger("InteractionLogger");
 var InteractionLogger = class {
   database;
   /**
@@ -6511,7 +6449,7 @@ var InteractionLogger = class {
    */
   constructor(database) {
     this.database = database;
-    logger17.debug("InteractionLogger initialized");
+    logger12.debug("InteractionLogger initialized");
   }
   /**
    * Log an interaction with a tool
@@ -6524,7 +6462,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
@@ -6540,13 +6478,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
       });
@@ -6559,16 +6497,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;
@@ -6579,11 +6517,11 @@ var InteractionLogger = class {
 // ../core/dist/instruction-generator.js
 var InstructionGenerator = class {
   projectDocsManager;
-  constructor(_planManager) {
-    this.projectDocsManager = new ProjectDocsManager();
+  constructor(logger14 = createLogger("InstructionGenerator")) {
+    this.projectDocsManager = new ProjectDocsManager(logger14);
   }
   /**
-   * Set the state machine definition for dynamic instruction generation
+   * No-op: all phase context is provided per-call via InstructionContext.
    */
   setStateMachine(_stateMachine) {
     return;
@@ -6596,7 +6534,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,
@@ -6627,43 +6564,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.
 
@@ -6674,7 +6604,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;
@@ -6688,13 +6618,16 @@ export {
   isModeledTransition,
   getContinuePhaseInstructions,
   LogLevel,
-  setMcpServerForLogging,
-  setMcpLoggingLevel,
+  registerLogSink,
+  clearLogSink,
+  setLoggingLevel,
+  setLoggingLevelFromString,
   createLogger,
   logger,
   StateMachineLoader,
   ConfigManager,
   WorkflowManager,
+  capitalizePhase,
   TransitionEngine,
   FileStorage,
   PathValidationUtils,