@exaudeus/workrail 0.1.10 → 0.2.2

package/dist/application/services/validation-engine.d.ts

@@ -41,4 +41,6 @@ export declare class ValidationEngine {
     validateLoopStep(step: LoopStep, workflow: Workflow): ValidationResult;
     validateWorkflow(workflow: Workflow): ValidationResult;
     private isValidVariableName;
+    private validateStepFunctionCalls;
+    private isArgTypeValid;
 }

package/dist/application/services/validation-engine.js

@@ -297,6 +297,12 @@ class ValidationEngine {
                         issues.push(`Nested loops are not currently supported. Inline step '${inlineStep.id}' is a loop`);
                         suggestions.push('Refactor to avoid nested loops');
                     }
+                    const callValidation = this.validateStepFunctionCalls(inlineStep, workflow.functionDefinitions || [], step.functionDefinitions || []);
+                    if (!callValidation.valid) {
+                        issues.push(...callValidation.issues.map(i => `Step '${inlineStep.id}': ${i}`));
+                        if (callValidation.suggestions)
+                            suggestions.push(...callValidation.suggestions);
+                    }
                 }
             }
         }
@@ -358,6 +364,12 @@ class ValidationEngine {
                 if (!step.prompt) {
                     issues.push(`Step '${step.id}' missing required prompt`);
                 }
+                const callValidation = this.validateStepFunctionCalls(step, workflow.functionDefinitions || []);
+                if (!callValidation.valid) {
+                    issues.push(...callValidation.issues.map(i => `Step '${step.id}': ${i}`));
+                    if (callValidation.suggestions)
+                        suggestions.push(...callValidation.suggestions);
+                }
             }
         }
         const loopBodySteps = new Set();
@@ -392,5 +404,59 @@ class ValidationEngine {
     isValidVariableName(name) {
         return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
     }
+    validateStepFunctionCalls(step, workflowDefs, loopDefs = []) {
+        const allDefs = {};
+        const addDefs = (defs) => {
+            (defs || []).forEach(d => { allDefs[d.name] = d; });
+        };
+        addDefs(workflowDefs);
+        addDefs(loopDefs);
+        addDefs(step.functionDefinitions);
+        const issues = [];
+        const suggestions = [];
+        const calls = step.functionCalls;
+        if (!calls || calls.length === 0) {
+            return { valid: true, issues: [], suggestions: [] };
+        }
+        for (const call of calls) {
+            const def = allDefs[call.name];
+            if (!def) {
+                issues.push(`Unknown function '${call.name}' in functionCalls`);
+                continue;
+            }
+            if (def.parameters && def.parameters.length > 0) {
+                const args = call.args || {};
+                for (const param of def.parameters) {
+                    if (param.required && !(param.name in args)) {
+                        issues.push(`Missing required parameter '${param.name}' for function '${call.name}'`);
+                    }
+                }
+                for (const [argName, argValue] of Object.entries(args)) {
+                    const spec = def.parameters.find(p => p.name === argName);
+                    if (!spec) {
+                        suggestions.push(`Unknown argument '${argName}' for function '${call.name}'`);
+                        continue;
+                    }
+                    if (!this.isArgTypeValid(argValue, spec)) {
+                        issues.push(`Invalid type for '${call.name}.${argName}': expected ${spec.type}`);
+                    }
+                    if (spec.enum && !spec.enum.includes(argValue)) {
+                        issues.push(`Invalid value for '${call.name}.${argName}': must be one of ${spec.enum.join(', ')}`);
+                    }
+                }
+            }
+        }
+        return { valid: issues.length === 0, issues, suggestions };
+    }
+    isArgTypeValid(value, spec) {
+        switch (spec.type) {
+            case 'string': return typeof value === 'string';
+            case 'number': return typeof value === 'number' && Number.isFinite(value);
+            case 'boolean': return typeof value === 'boolean';
+            case 'array': return Array.isArray(value);
+            case 'object': return value !== null && typeof value === 'object' && !Array.isArray(value);
+            default: return true;
+        }
+    }
 }
 exports.ValidationEngine = ValidationEngine;

package/dist/application/services/workflow-service.d.ts

@@ -34,6 +34,8 @@ export declare class DefaultWorkflowService implements WorkflowService {
         context?: ConditionContext;
     }>;
     private buildStepPrompt;
+    private collectConditionVars;
+    private collectEqualsValues;
     private findLoopStepById;
     validateStepOutput(workflowId: string, stepId: string, output: string): Promise<{
         valid: boolean;

package/dist/application/services/workflow-service.js

@@ -189,6 +189,61 @@ class DefaultWorkflowService {
             }
             return this.getNextStep(workflowId, completedSteps, loopStartSizeCheck.context);
         }
+        if (!nextStep) {
+            const remainingConditionalSteps = workflow.steps.filter((step) => {
+                if (completed.includes(step.id))
+                    return false;
+                if (loopBodySteps.has(step.id))
+                    return false;
+                return !!step.runCondition;
+            });
+            if (remainingConditionalSteps.length > 0) {
+                const requiredVars = new Set();
+                const allowedValues = {};
+                for (const step of remainingConditionalSteps) {
+                    const condition = step.runCondition;
+                    this.collectConditionVars(condition, requiredVars);
+                    this.collectEqualsValues(condition, allowedValues);
+                }
+                const issues = [];
+                for (const variableName of requiredVars) {
+                    const currentValue = enhancedContext[variableName];
+                    const allowed = allowedValues[variableName]
+                        ? Array.from(allowedValues[variableName])
+                        : [];
+                    if (currentValue === undefined || currentValue === null || currentValue === '') {
+                        if (allowed.length > 0) {
+                            issues.push(`Set '${variableName}' to one of: ${allowed.map(v => `'${v}'`).join(', ')}`);
+                        }
+                        else {
+                            issues.push(`Provide a value for '${variableName}'`);
+                        }
+                    }
+                    else if (allowed.length > 0) {
+                        const matchesExactly = allowed.some(v => v === String(currentValue));
+                        const matchesCaseInsensitive = allowed.some(v => v.toLowerCase() === String(currentValue).toLowerCase());
+                        if (!matchesExactly) {
+                            if (matchesCaseInsensitive) {
+                                issues.push(`Normalize casing for '${variableName}': use one of ${allowed.map(v => `'${v}'`).join(', ')} (current '${currentValue}')`);
+                            }
+                            else {
+                                issues.push(`Adjust '${variableName}' to one of: ${allowed.map(v => `'${v}'`).join(', ')} (current '${currentValue}')`);
+                            }
+                        }
+                    }
+                }
+                if (issues.length > 0) {
+                    return {
+                        step: null,
+                        guidance: {
+                            prompt: `No eligible step due to unmet conditions. Please update context:\n- ${issues.join('\n- ')}`
+                        },
+                        isComplete: false,
+                        context: enhancedContext
+                    };
+                }
+            }
+        }
         const isComplete = !nextStep;
         let finalPrompt = 'Workflow complete.';
         if (nextStep) {
@@ -232,6 +287,46 @@ class DefaultWorkflowService {
         }
         return finalPrompt;
     }
+    collectConditionVars(condition, sink) {
+        if (!condition || typeof condition !== 'object')
+            return;
+        if (typeof condition.var === 'string' && condition.var.length > 0) {
+            sink.add(condition.var);
+        }
+        if (Array.isArray(condition.and)) {
+            for (const sub of condition.and)
+                this.collectConditionVars(sub, sink);
+        }
+        if (Array.isArray(condition.or)) {
+            for (const sub of condition.or)
+                this.collectConditionVars(sub, sink);
+        }
+        if (condition.not)
+            this.collectConditionVars(condition.not, sink);
+    }
+    collectEqualsValues(condition, sink) {
+        if (!condition || typeof condition !== 'object')
+            return;
+        if (typeof condition.var === 'string' && Object.prototype.hasOwnProperty.call(condition, 'equals')) {
+            const variableName = condition.var;
+            const value = condition.equals;
+            if (value !== undefined && value !== null) {
+                if (!sink[variableName])
+                    sink[variableName] = new Set();
+                sink[variableName].add(String(value));
+            }
+        }
+        if (Array.isArray(condition.and)) {
+            for (const sub of condition.and)
+                this.collectEqualsValues(sub, sink);
+        }
+        if (Array.isArray(condition.or)) {
+            for (const sub of condition.or)
+                this.collectEqualsValues(sub, sink);
+        }
+        if (condition.not)
+            this.collectEqualsValues(condition.not, sink);
+    }
     findLoopStepById(workflow, stepId) {
         const step = workflow.steps.find(s => s.id === stepId);
         return step && (0, workflow_types_1.isLoopStep)(step) ? step : null;

package/dist/infrastructure/storage/multi-directory-workflow-storage.js

@@ -20,9 +20,13 @@ class MultiDirectoryWorkflowStorage {
     resolveDirectories(options) {
         const directories = [];
         if (!options.excludeBundled) {
-            const bundledDir = path_1.default.resolve(__dirname, '../../../workflows');
-            if ((0, fs_1.existsSync)(bundledDir)) {
-                directories.push(bundledDir);
+            const bundledSrcDir = path_1.default.resolve(__dirname, '../../../../workflows');
+            const bundledDistDir = path_1.default.resolve(__dirname, '../../../workflows');
+            if ((0, fs_1.existsSync)(bundledSrcDir)) {
+                directories.push(bundledSrcDir);
+            }
+            else if ((0, fs_1.existsSync)(bundledDistDir)) {
+                directories.push(bundledDistDir);
             }
         }
         if (!options.excludeUser) {

package/dist/types/mcp-types.d.ts

@@ -118,6 +118,24 @@ export interface WorkflowGetRequest extends MCPToolCallRequest {
         id: string;
     };
 }
+export interface FunctionParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    required?: boolean;
+    description?: string;
+    enum?: Array<string | number | boolean>;
+    default?: unknown;
+}
+export interface FunctionDefinition {
+    name: string;
+    definition: string;
+    parameters?: FunctionParameter[];
+    scope?: 'workflow' | 'loop' | 'step';
+}
+export interface FunctionCall {
+    name: string;
+    args: Record<string, unknown>;
+}
 export interface WorkflowStep {
     id: string;
     title: string;
@@ -127,6 +145,9 @@ export interface WorkflowStep {
     askForFiles?: boolean;
     requireConfirmation?: boolean;
     runCondition?: object;
+    functionDefinitions?: FunctionDefinition[];
+    functionCalls?: FunctionCall[];
+    functionReferences?: string[];
 }
 export interface Workflow {
     id: string;
@@ -137,6 +158,7 @@ export interface Workflow {
     clarificationPrompts?: string[];
     steps: WorkflowStep[];
     metaGuidance?: string[];
+    functionDefinitions?: FunctionDefinition[];
 }
 export interface WorkflowGetResponse extends MCPToolCallResponse {
     result: Workflow;

package/dist/types/workflow-types.d.ts

@@ -20,6 +20,7 @@ export interface WorkflowStep {
     requireConfirmation?: boolean;
     runCondition?: object;
     functionDefinitions?: FunctionDefinition[];
+    functionCalls?: FunctionCall[];
     functionReferences?: string[];
 }
 export interface LoopStep extends WorkflowStep {
@@ -82,11 +83,24 @@ export interface LoopPhaseReference {
     totalSteps: number;
     functionDefinitions?: FunctionDefinition[];
 }
+export interface FunctionParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    required?: boolean;
+    description?: string;
+    enum?: Array<string | number | boolean>;
+    default?: unknown;
+}
 export interface FunctionDefinition {
     name: string;
     definition: string;
+    parameters?: FunctionParameter[];
     scope?: 'workflow' | 'loop' | 'step';
 }
+export interface FunctionCall {
+    name: string;
+    args: Record<string, unknown>;
+}
 export declare function isLoopStep(step: WorkflowStep | LoopStep): step is LoopStep;
 export declare function isFirstLoopIteration(context: EnhancedContext | OptimizedLoopContext): boolean;
 export interface WorkflowValidationResult {

package/dist/validation/response-validator.js

@@ -11,6 +11,24 @@ const workflowSummarySchema = zod_1.z.object({
     category: zod_1.z.string(),
     version: zod_1.z.string()
 });
+const functionParameterSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    type: zod_1.z.enum(['string', 'number', 'boolean', 'array', 'object']),
+    required: zod_1.z.boolean().optional(),
+    description: zod_1.z.string().optional(),
+    enum: zod_1.z.array(zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.boolean()])).optional(),
+    default: zod_1.z.any().optional()
+});
+const functionDefinitionSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    definition: zod_1.z.string(),
+    parameters: zod_1.z.array(functionParameterSchema).optional(),
+    scope: zod_1.z.enum(['workflow', 'loop', 'step']).optional()
+});
+const functionCallSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    args: zod_1.z.record(zod_1.z.any())
+});
 const workflowStepSchema = zod_1.z.object({
     id: zod_1.z.string().regex(idRegex),
     title: zod_1.z.string(),
@@ -19,7 +37,10 @@ const workflowStepSchema = zod_1.z.object({
     guidance: zod_1.z.array(zod_1.z.string()).optional(),
     askForFiles: zod_1.z.boolean().optional(),
     requireConfirmation: zod_1.z.boolean().optional(),
-    runCondition: zod_1.z.object({}).optional()
+    runCondition: zod_1.z.object({}).optional(),
+    functionDefinitions: zod_1.z.array(functionDefinitionSchema).optional(),
+    functionCalls: zod_1.z.array(functionCallSchema).optional(),
+    functionReferences: zod_1.z.array(zod_1.z.string()).optional()
 });
 const workflowSchema = zod_1.z.object({
     id: zod_1.z.string().regex(idRegex),
@@ -29,7 +50,8 @@ const workflowSchema = zod_1.z.object({
     preconditions: zod_1.z.array(zod_1.z.string()).optional(),
     clarificationPrompts: zod_1.z.array(zod_1.z.string()).optional(),
     steps: zod_1.z.array(workflowStepSchema),
-    metaGuidance: zod_1.z.array(zod_1.z.string()).optional()
+    metaGuidance: zod_1.z.array(zod_1.z.string()).optional(),
+    functionDefinitions: zod_1.z.array(functionDefinitionSchema).optional()
 });
 const workflowMetadataSchema = zod_1.z.object({
     id: zod_1.z.string().regex(idRegex),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exaudeus/workrail",
-  "version": "0.1.10",
+  "version": "0.2.2",
   "description": "MCP server for structured workflow orchestration and step-by-step task guidance",
   "license": "MIT",
   "bin": {
@@ -16,7 +16,8 @@
     "release": "bash -c './scripts/release.sh'",
     "dev": "npm run build && node dist/mcp-server.js",
     "prepare": "npm run build",
-    "watch": "tsc --watch"
+    "watch": "tsc --watch",
+    "preinstall": "node -e \"const v=parseInt(process.versions.node.split('.') [0],10); if(v<20){console.error('WorkRail requires Node.js >=20. Current: '+process.versions.node+'\\nPlease upgrade: https://nodejs.org/'); process.exit(1);}\""
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^0.5.0",
@@ -42,5 +43,8 @@
     "@types/node": "^20.19.9",
     "@types/semver": "^7.7.0",
     "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=20"
   }
 }

package/spec/workflow.schema.json

@@ -90,6 +90,13 @@
             "type": "string",
             "description": "The function definition explaining what it does"
           },
+          "parameters": {
+            "type": "array",
+            "description": "Optional machine-readable parameter specifications for this function.",
+            "items": {
+              "$ref": "#/$defs/functionParameter"
+            }
+          },
           "scope": {
             "type": "string",
             "enum": ["workflow", "loop", "step"],
@@ -117,23 +124,34 @@
       "minLength": 3,
       "maxLength": 64
     },
-    "functionDefinition": {
+    "functionParameter": {
       "type": "object",
+      "description": "Specification for a single function parameter.",
       "properties": {
-        "name": {
-          "type": "string",
-          "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$",
-          "description": "Function name following JavaScript identifier rules"
+        "name": { "type": "string", "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" },
+        "type": { "type": "string", "enum": ["string", "number", "boolean", "array", "object"] },
+        "required": { "type": "boolean" },
+        "description": { "type": "string" },
+        "enum": {
+          "type": "array",
+          "items": { "oneOf": [ {"type": "string"}, {"type": "number"}, {"type": "boolean"} ] },
+          "minItems": 1
         },
-        "definition": {
-          "type": "string",
-          "description": "The function definition explaining what it does"
+        "default": {}
+      },
+      "required": ["name", "type"],
+      "additionalProperties": false
+    },
+    "functionDefinition": {
+      "type": "object",
+      "properties": {
+        "name": { "type": "string", "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" },
+        "definition": { "type": "string" },
+        "parameters": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/functionParameter" }
         },
-        "scope": {
-          "type": "string",
-          "enum": ["workflow", "loop", "step"],
-          "description": "Scope where this function is available"
-        }
+        "scope": { "type": "string", "enum": ["workflow", "loop", "step"] }
       },
       "required": ["name", "definition"],
       "additionalProperties": false
@@ -141,87 +159,21 @@
     "standardStep": {
       "type": "object",
       "properties": {
-        "id": {
-          "$ref": "#/$defs/stepId",
-          "description": "Unique identifier for the step"
-        },
-        "title": {
-          "type": "string",
-          "description": "Human-friendly title of the step",
-          "minLength": 1,
-          "maxLength": 128
-        },
-        "prompt": {
-          "type": "string",
-          "description": "The detailed instructions or prompt for this step.",
-          "minLength": 1,
-          "maxLength": 2048
-        },
-        "agentRole": {
-          "type": "string",
-          "description": "Optional behavioral instructions for AI agents defining how they should approach and execute this step. This content is not shown to users.",
-          "minLength": 10,
-          "maxLength": 1024
-        },
-        "guidance": {
-          "type": "array",
-          "description": "Optional array of strings providing tactical advice for this step.",
-          "items": {
-            "type": "string"
-          }
-        },
-        "askForFiles": {
-          "type": "boolean",
-          "description": "Whether the agent should ask for relevant files before executing the step.",
-          "default": false
-        },
-        "hasValidation": {
-          "type": "boolean",
-          "description": "Whether this step has validation logic that should be called. Set to true for steps with validationCriteria to optimize execution performance.",
-          "default": false
-        },
-        "requireConfirmation": {
-          "$ref": "#/$defs/confirmationRule"
-        },
-        "runCondition": {
-          "$ref": "#/$defs/condition"
-        },
-        "validationCriteria": {
-          "description": "Optional validation rules to check step output quality. Can be an array of rules (all must pass) or a composition object with logical operators.",
-          "oneOf": [
-            {
-              "type": "array",
-              "description": "Array of validation rules (all must pass)",
-              "items": {
-                "$ref": "#/$defs/validationRule"
-              }
-            },
-            {
-              "$ref": "#/$defs/validationComposition"
-            }
-          ]
-        },
-        "functionDefinitions": {
-          "type": "array",
-          "description": "Function definitions specific to this step. Agents can reference these for understanding step-specific patterns.",
-          "items": {
-            "$ref": "#/$defs/functionDefinition"
-          }
-        },
-        "functionReferences": {
-          "type": "array",
-          "description": "References to functions defined at workflow or loop level that this step uses.",
-          "items": {
-            "type": "string",
-            "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*\\(\\)$"
-          }
-        }
+        "id": { "$ref": "#/$defs/stepId", "description": "Unique identifier for the step" },
+        "title": { "type": "string", "minLength": 1, "maxLength": 128 },
+        "prompt": { "type": "string", "minLength": 1, "maxLength": 2048 },
+        "agentRole": { "type": "string", "minLength": 10, "maxLength": 1024 },
+        "guidance": { "type": "array", "items": { "type": "string" } },
+        "askForFiles": { "type": "boolean", "default": false },
+        "hasValidation": { "type": "boolean", "default": false },
+        "requireConfirmation": { "$ref": "#/$defs/confirmationRule" },
+        "runCondition": { "$ref": "#/$defs/condition" },
+        "validationCriteria": { "oneOf": [ { "type": "array", "items": { "$ref": "#/$defs/validationRule" } }, { "$ref": "#/$defs/validationComposition" } ] },
+        "functionDefinitions": { "type": "array", "items": { "$ref": "#/$defs/functionDefinition" } },
+        "functionCalls": { "type": "array", "items": { "$ref": "#/$defs/functionCall" } },
+        "functionReferences": { "type": "array", "items": { "type": "string", "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*\\(\\)$" } }
       },
-      "required": [
-        "id",
-        "title",
-        "prompt"
-      ],
+      "required": ["id", "title", "prompt"],
       "additionalProperties": false
     },
     "loopStep": {
@@ -563,6 +515,15 @@
           "$ref": "#/$defs/validationComposition"
         }
       ]
+    },
+    "functionCall": {
+      "type": "object",
+      "properties": {
+        "name": { "type": "string", "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" },
+        "args": { "type": "object", "additionalProperties": true }
+      },
+      "required": ["name", "args"],
+      "additionalProperties": false
     }
   }
 }

package/workflows/coding-task-workflow-with-loops.json

@@ -431,7 +431,7 @@
                 {
                     "id": "phase-6-prep",
                     "title": "PREP: Prepare for Step {{currentStepNumber + 1}}",
-                    "prompt": "**PREPARATION PHASE for Step {{currentStepNumber + 1}}/{{totalImplementationSteps}}**\n\nBefore implementing this step, you must first PREPARE:\n\n1. **Read implementation_plan.md** and locate step #{{currentStepNumber + 1}}\n2. **Extract step details**: Note the title, description, and expected outputs\n3. **Confirm prerequisites**: Verify the previous step (if any) was completed correctly\n4. **Validate current state**: Ensure the plan for this step is still valid in the current codebase\n5. **List requirements**: Identify all required inputs, files, or dependencies\n\n**BRANCH SETUP (first iteration only):** If this is the first implementation step ({{currentStepNumber}} === 0):\n- Check git availability with 'git status'\n- If available, create feature branch: 'git checkout -b wip-[unique-task-id]'\n- Track the featureBranch variable for later use\n- If git unavailable: Skip branching, log in CONTEXT.md\n\n**CRITICAL CONTEXT OPTIMIZATION:**\nWhen calling workflow_next after this step, send ONLY:\n- currentStepNumber and totalImplementationSteps\n- Any NEW variables you created (like featureBranch)\n- DO NOT send: arrays, plans, _loopState, _currentLoop, unchanged data\n\n**Do not proceed if anything is unclear or missing.**",
+                    "prompt": "**PREPARATION PHASE for Step {{currentStepNumber + 1}}/{{totalImplementationSteps}}**\n\nBefore implementing this step, you must first PREPARE:\n\n1. **Read implementation_plan.md** and locate step #{{currentStepNumber + 1}}\n2. **Extract step details**: Note the title, description, and expected outputs\n3. **Confirm prerequisites**: Verify the previous step (if any) was completed correctly\n4. **Validate current state**: Ensure the plan for this step is still valid in the current codebase\n5. **List requirements**: Identify all required inputs, files, or dependencies\n\n**BRANCH SETUP (first iteration only):** If this is the first implementation step ({{currentStepNumber}} === 0):\n- Check git availability with 'git status'\n- If available, create feature branch: 'git checkout -b wip-[unique-task-id]'\n- Track the featureBranch variable for later use\n- If git unavailable: Skip branching, log in CONTEXT.md\n\n**Do not proceed if anything is unclear or missing.**",
                     "agentRole": "You are preparing to implement a specific step from the plan. Be meticulous in verifying all prerequisites are met before proceeding.",
                     "guidance": [
                         "This is step {{currentStepNumber + 1}} of {{totalImplementationSteps}} total implementation steps",
@@ -444,7 +444,7 @@
                 {
                     "id": "phase-6-implement",
                     "title": "IMPLEMENT: Execute Step {{currentStepNumber + 1}}",
-                    "prompt": "**IMPLEMENTATION PHASE for Step {{currentStepNumber + 1}}/{{totalImplementationSteps}}**\n\nNow implement the step you just prepared for:\n\n**Instructions:**\n1. Re-read step #{{currentStepNumber + 1}} from implementation_plan.md\n2. Focus only on this single step\n3. useTools() to make code changes\n4. Follow quality standards\n5. Adapt to unexpected discoveries\n6. createFile() for ALL code changes\n\n**Remember:** applyUserRules() and matchPatterns() throughout.\n\n**Progress Tracking:**\n- This is step {{currentStepNumber + 1}} of {{totalImplementationSteps}}\n- If we've done > 20 steps total, pause for user intervention\n\n**CONTEXT UPDATES:** If this is every 3rd step ({{currentStepNumber + 1}} % 3 === 0):\n- Update CONTEXT.md\n- addResumptionJson(phase-6-implement)\n- updateDecisionLog()\n- List files modified with line ranges\n\n**CONTEXT OPTIMIZATION for workflow_next:**\nSend ONLY: currentStepNumber, totalImplementationSteps, filesCreated (new), any other NEW data\nDO NOT send: arrays, plans, _loopState, unchanged fields",
+                    "prompt": "**IMPLEMENTATION PHASE for Step {{currentStepNumber + 1}}/{{totalImplementationSteps}}**\n\nNow implement the step you just prepared for:\n\n**Instructions:**\n1. Re-read step #{{currentStepNumber + 1}} from implementation_plan.md\n2. Focus only on this single step\n3. useTools() to make code changes\n4. Follow quality standards\n5. Adapt to unexpected discoveries\n6. createFile() for ALL code changes\n\n**Remember:** applyUserRules() and matchPatterns() throughout.\n\n**Progress Tracking:**\n- This is step {{currentStepNumber + 1}} of {{totalImplementationSteps}}\n- If we've done > 20 steps total, pause for user intervention\n\n**CONTEXT UPDATES:** If this is every 3rd step ({{currentStepNumber + 1}} % 3 === 0):\n- Update CONTEXT.md\n- addResumptionJson(phase-6-implement)\n- updateDecisionLog()\n- List files modified with line ranges\n\n",
                     "agentRole": "You are implementing a specific step from the approved plan. Focus on precise execution while maintaining code quality.",
                     "guidance": [
                         "Implement only what this step requires",
@@ -456,7 +456,7 @@
                 {
                     "id": "phase-6-verify",
                     "title": "VERIFY: Validate Step {{currentStepNumber + 1}}",
-                    "prompt": "**VERIFICATION PHASE for Step {{currentStepNumber + 1}}/{{totalImplementationSteps}}**\n\nVerify the implementation is complete and correct:\n\n**Required:** verifyImplementation()\n\n**COMMIT Decision (if all passes):**\n- checkAutomation(commit)\n- gitCommit(type, scope: description)\n- If git unavailable: Log in CONTEXT.md\n\n**FAILURE PROTOCOL:** If verification fails after 2 attempts:\n1. Do not try a third time\n2. Fall back to alternative tools\n3. updateDecisionLog() with failure details\n4. Present summary and recommendations\n5. Set 'verificationFailed' context variable to true\n\n**CONTEXT OPTIMIZATION:**\nFor workflow_next, send ONLY what changed: currentStepNumber, verificationResult, verificationFailed (if true)\nNEVER send back the full context!",
+                    "prompt": "**VERIFICATION PHASE for Step {{currentStepNumber + 1}}/{{totalImplementationSteps}}**\n\nVerify the implementation is complete and correct:\n\n**Required:** verifyImplementation()\n\n**COMMIT Decision (if all passes):**\n- checkAutomation(commit)\n- gitCommit(type, scope: description)\n- If git unavailable: Log in CONTEXT.md\n\n**FAILURE PROTOCOL:** If verification fails after 2 attempts:\n1. Do not try a third time\n2. Fall back to alternative tools\n3. updateDecisionLog() with failure details\n4. Present summary and recommendations\n5. Set 'verificationFailed' context variable to true\n\n",
                     "agentRole": "You are verifying the implementation meets all quality standards. Be thorough but respect failure bounds.",
                     "guidance": [
                         "All three verification steps must pass",

package/workflows/intelligent-test-case-generation.json

@@ -0,0 +1,237 @@
+{
+  "id": "intelligent-test-case-generation",
+  "name": "Intelligent Test Case Generation from Tickets",
+  "version": "0.0.1",
+  "description": "Transforms ticket requirements into systematic test cases using evidence-driven analysis, dual-brain processing (NLP + LLM), document discovery, and progressive scenario expansion. Produces integration and end-to-end tests optimized for developer readability and LLM consumption with confidence scoring and validation loops.",
+  "preconditions": [
+    "Agent has access to codebase analysis tools (grep, file readers, semantic search)",
+    "User can provide ticket information in any standard format (JIRA, GitHub Issues, etc.)",
+    "Agent has access to document analysis capabilities for BRDs, architecture docs, specs",
+    "Workflow execution environment supports confidence scoring and validation loops"
+  ],
+  "clarificationPrompts": [
+    "What ticket system are you using? (JIRA, GitHub Issues, Azure DevOps, etc.)",
+    "What's your team's experience level with test case creation? (Mixed junior/senior, mostly senior, mostly junior)",
+    "Do you have existing test patterns or frameworks we should align with?",
+    "What automation level do you prefer? (High: auto-approve >8.0 confidence, Medium: standard confirmations, Low: extra validation)",
+    "Are there specific document repositories we should search? (Confluence, SharePoint, Git repos, etc.)"
+  ],
+  "metaGuidance": [
+    "PAUSE POLICY: If required variables are missing and no assumptions accepted, pause and ask targeted questions before proceeding.",
+    "EVIDENCE POLICY: If evidenceScore < threshold, request more sources and do not proceed until satisfied or assumptions are accepted.",
+    "ASSUMPTION POLICY: Proceed with documented assumptions only after explicit confirmation; record risks and mitigation.",
+    "DUAL-BRAIN PROCESSING: Always use both structured NLP extraction AND creative LLM expansion for comprehensive coverage.",
+    "CONFIDENCE CALIBRATION: Use mathematical confidence framework with adjustable thresholds based on automation level.",
+    "LIVING DOCUMENTATION: Maintain TEST_CONTEXT.md throughout workflow. Update after major milestones for session continuity.",
+    "HYPOTHESIS-DRIVEN TESTING: Generate test hypotheses first, then validate with evidence.",
+    "**FUNCTION DEFINITIONS:** fun analyzeTicket(depth=1|2|3) = 'Analyze ticket at specified depth levels: L1=requirements, L2=dependencies, L3=system impact. Extract entities, actions, data flows, acceptance criteria.'",
+    "fun evaluateReadiness() = 'Compute requiredVarsFound, missingVars[], completenessScore (0-1) from context. Set proceed/question/assumption flags.'",
+    "fun collectEvidence(minimumSources=3) = 'Gather supporting evidence for hypotheses. Score evidence quality 1-10. Document sources and confidence levels.'",
+    "fun discoverDocuments(types) = 'Search for missing documentation via semantic search. Types may include BRDs, ArchitectureDocs, ApiSpecs, ExistingTests. Score relevance and completeness.'",
+    "fun scoreAndValidate(autoApproveThreshold=8.0) = 'Score item using criteria (1-10). Apply gates: >8.0 auto-approve; 6.0–7.9 review; <6.0 require additional evidence.'",
+    "fun updateTestContext(sections) = 'Maintain TEST_CONTEXT.md: ticket analysis, evidence, hypotheses, confidence scores, validation results.'",
+    "fun dualBrainProcess(enableNlp=true, enableCreative=true) = 'Stage 1: NLP extraction of structured data (entities, dependencies, flows). Stage 2: LLM creative expansion (edge cases, negative paths, integration scenarios).'",
+    "fun generateTestHypotheses(count=5) = 'Create 3–5 test hypotheses focused on integration/E2E scenarios. Include risk assessment.'",
+    "fun progressiveExpansion(levels) = 'Expand scenarios in layers: Core→Edge→System→Chaos. Adapt complexity to user experience.'",
+    "fun adaptToUserLevel(level=Junior|Mixed|Senior) = 'Deliver content adapted to the selected user level.'",
+    "fun scoreConfidence(weights) = 'Calculate confidence (1-10) using: requirements clarity, system context, evidence quality, coverage completeness.'",
+    "fun validateCoverage(minScore=7) = 'Assess coverage completeness; identify gaps; score coverage 1-10; suggest additional scenarios if needed.'",
+    "fun formatDualOutput(human=true, machine=true) = 'Generate both human-readable (Gherkin/Markdown) and machine-readable (JSON/structured) formats simultaneously.'",
+    "fun buildTicketSignature() = 'Extract entities, acceptance criteria, identifiers (ticket ID), impacted modules, user flows; output tokens/phrases and canonical signature.'",
+    "fun scoreDocRelevance(chunk, signature) = 'Compute lexical+semantic relevance; detect explicit mentions of ticket ID/criteria; return relevanceScore 0–1 with rationale.'",
+    "fun extractCitations(criteria) = 'For each acceptance criterion, locate explicit quotes/snippets with {doc, section, quote, relevanceScore}.'",
+    "fun computeCriteriaCoverage() = 'Compute fraction (0–1) of acceptance criteria with ≥1 strong citation.'",
+    "fun computeTicketSpecificEvidenceScore() = 'Aggregate evidence quality emphasizing ticket specificity; scale 1–10.'",
+    "fun computeDocNoiseRatio() = 'Compute proportion (0–1) of cited text that is generic/non-ticket; lower is better.'"
+  ],
+  "steps": [
+    {
+      "id": "phase-0-intelligent-triage",
+      "title": "Phase 0: Intelligent Ticket Triage & Context Setup",
+      "prompt": "**SYSTEMATIC TEST GENERATION BEGINS** - Transform ticket requirements into comprehensive test cases through evidence-driven analysis.\n\nanalyzeTicket(depth=3) and buildTicketSignature() to establish foundation:\n\n**STEP 1: Ticket Analysis & Classification**\n- **Ticket Information**: Please provide the complete ticket details (title, description, acceptance criteria, labels, etc.)\n- **System Context**: What system/component does this ticket affect?\n- **Change Type**: Is this a new feature, bug fix, enhancement, or refactoring?\n- **Risk Assessment**: What's the business impact if this functionality fails?\n\n**STEP 2: Complexity & Scope Assessment**\nBased on the ticket analysis, I'll classify the testing complexity:\n- **Simple**: Single component, clear requirements, minimal integration\n- **Standard**: Multiple components, moderate integration, some unknowns\n- **Complex**: Cross-system changes, high integration, significant risk\n\n**STEP 3: User Experience Level**\nWhat's your experience level with test case creation?\n- **Junior**: Need detailed guidance and explanations\n- **Mixed**: Team has varying skill levels\n- **Senior**: Prefer efficient, advanced patterns\n\n**STEP 4: Automation Preferences**\nWhat automation level do you prefer?\n- **High**: Auto-approve confidence >8.0, minimal confirmations\n- **Medium**: Standard confirmations for key decisions\n- **Low**: Extra validation for comprehensive coverage\n\n**OUTPUTS**: Set context variables for adaptive workflow execution, including ticketSignature.",
+      "agentRole": "You are a senior test strategy specialist with expertise in analyzing software requirements and determining optimal testing approaches. Your role is to quickly assess ticket complexity, understand system context, and set up the workflow for systematic test case generation.",
+      "guidance": [
+        "THOROUGH ANALYSIS: Extract all relevant information from ticket details",
+        "CONTEXT AWARENESS: Understand the ticket's place in the larger system",
+        "ADAPTIVE SETUP: Configure workflow based on user experience and preferences",
+        "EVIDENCE FOUNDATION: Establish the evidence base for systematic test generation"
+      ],
+      "requireConfirmation": true
+    },
+    {
+      "id": "phase-0b-readiness",
+      "title": "Phase 0b: Readiness Evaluation (Soft Gate)",
+      "prompt": "Evaluate readiness: compute requiredVarsFound, missingVars[], completenessScore (0-1), gather evidence, set evidenceScore (1-10). Outcome flags: proceedNeeded, questioningNeeded, assumptionNeeded.",
+      "askForFiles": true,
+      "hasValidation": true,
+      "validationCriteria": [
+        { "type": "length", "min": 200, "message": "Summarize readiness and evidence (≥200 chars)" }
+      ],
+      "requireConfirmation": true
+    },
+    {
+      "id": "phase-0c-questioning-loop",
+      "type": "loop",
+      "title": "Resolve Missing Inputs",
+      "loop": { "type": "forEach", "items": "missingVars", "itemVar": "missing", "maxIterations": 5 },
+      "body": [
+        {
+          "id": "ask-missing",
+          "title": "Provide: {{missing}}",
+          "prompt": "Please provide '{{missing}}'. If unknown, choose an option or confirm an assumption. Attach links/files if applicable.",
+          "askForFiles": true,
+          "requireConfirmation": true
+        }
+      ]
+    },
+    {
+      "id": "phase-0d-assumptions",
+      "title": "Assumption Proposal & Risks",
+      "prompt": "Propose explicit assumptions for remaining gaps with risks and mitigation. Confirm to proceed and record assumptions[].",
+      "requireConfirmation": true
+    },
+    {
+      "id": "phase-1-evidence-gathering",
+      "runCondition": {
+        "and": [
+          { "or": [ { "var": "completenessScore", "gte": 0.7 }, { "var": "assumptionAccepted", "equals": true } ] },
+          { "var": "evidenceScore", "gte": 7.5 }
+        ]
+      },
+      "title": "Phase 1: Evidence Gathering & Ticket-Specific Scoring",
+      "prompt": "collectEvidence(ticket requirements) and discoverDocuments(system context)\n\n**TICKET-SPECIFIC EVIDENCE COLLECTION**\n- scoreDocRelevance(each document chunk, ticketSignature)\n- extractCitations(acceptance criteria) and build evidenceMap: criterion -> [{doc, section, quote, relevanceScore}]\n- computeCriteriaCoverage()\n- computeTicketSpecificEvidenceScore()\n- computeDocNoiseRatio()\n\nscoreAndValidate(evidence completeness, 7/10 threshold)\n\nupdateTestContext(evidence-analysis, evidenceMap, criteriaCoverage, ticketSpecificEvidenceScore, docNoiseRatio)\n\n**QUALITY GATE**: Require criteriaCoverage ≥ 0.7, ticketSpecificEvidenceScore ≥ 7.0, docNoiseRatio ≤ 0.3 before proceeding.",
+      "agentRole": "You are a systematic evidence analyst specializing in gathering comprehensive context for test case generation. Your expertise lies in identifying information gaps, discovering relevant documentation, and building complete evidence bases for reliable test design.",
+      "guidance": [
+        "SYSTEMATIC COLLECTION: Use structured approach to gather all relevant evidence",
+        "GAP IDENTIFICATION: Actively identify and address missing information",
+        "DOCUMENT DISCOVERY: Use semantic search and intelligent questioning to find context",
+        "QUALITY THRESHOLD: Don't proceed without sufficient evidence foundation"
+      ],
+      "validationCriteria": [
+        { "type": "length", "min": 200, "message": "Evidence collection must be comprehensive (minimum 200 characters of analysis)" },
+        { "type": "regex", "pattern": "criteriaCoverage|coverage", "flags": "i", "message": "Include criteriaCoverage metric" },
+        { "type": "regex", "pattern": "docNoiseRatio", "flags": "i", "message": "Include docNoiseRatio metric" },
+        { "type": "regex", "pattern": "evidenceMap|citation|quote", "flags": "i", "message": "Provide explicit citations/quotes per criterion" }
+      ],
+      "hasValidation": true
+    },
+    {
+      "id": "phase-1b-evidence-audit",
+      "title": "Phase 1b: Evidence Audit (Ticket-Specific)",
+      "prompt": "Audit the ticket-specific evidence before hypothesis formation.\n\n**Produce:**\n- evidenceMap (acceptance criterion -> citations with {doc, section, quote, relevanceScore})\n- criteriaCoverage (0–1), ticketSpecificEvidenceScore (1–10), docNoiseRatio (0–1)\n- Brief rationale for any low-coverage criteria and targeted follow-up actions\n\nConfirm metrics and highlight gaps. Do not proceed if coverage/noise thresholds are not met.",
+      "validationCriteria": [
+        { "type": "regex", "pattern": "evidenceMap|criterion", "flags": "i", "message": "Include evidenceMap mapping criteria to citations" },
+        { "type": "regex", "pattern": "criteriaCoverage|ticketSpecificEvidenceScore|docNoiseRatio", "flags": "i", "message": "Report ticket-specific metrics" }
+      ],
+      "hasValidation": true,
+      "requireConfirmation": true
+    },
+    {
+      "id": "phase-2-gap-check",
+      "title": "Phase 2 Gap Check",
+      "prompt": "Quick gap check before hypotheses. If new gaps detected, append to openQuestions and run questioning loop once.",
+      "runCondition": { "or": [ { "var": "newGapsDetected", "equals": true }, { "var": "newGapsDetected", "equals": false } ] }
+    },
+    {
+      "id": "phase-2-dual-brain-analysis",
+      "runCondition": {
+        "and": [
+          { "or": [ { "var": "completenessScore", "gte": 0.7 }, { "var": "assumptionAccepted", "equals": true } ] },
+          { "var": "evidenceScore", "gte": 7.5 },
+          { "var": "criteriaCoverage", "gte": 0.7 },
+          { "var": "docNoiseRatio", "lte": 0.3 },
+          { "var": "ticketSpecificEvidenceScore", "gte": 7.0 }
+        ]
+      },
+      "title": "Phase 2: Dual-Brain Processing & Hypothesis Formation",
+      "prompt": "dualBrainProcess(collected evidence) and generateTestHypotheses(ticket, context)\n\n**DUAL-BRAIN PROCESSING ARCHITECTURE**\nCombine structured NLP analysis with creative LLM expansion to generate comprehensive test hypotheses.\n\nscoreAndValidate(each hypothesis, testability criteria)\n\nupdateTestContext(hypothesis-analysis, ranked test hypotheses with risk assessment)\n\n**QUALITY GATE**: Maximum 5 hypotheses, each scored for testability and business impact.",
+      "agentRole": "You are a dual-brain test analysis expert combining systematic NLP processing with creative scenario generation. Your role is to extract structured information while also discovering creative test scenarios that human analysts might miss.",
+      "guidance": [
+        "STRUCTURED EXTRACTION: Use NLP techniques for systematic information parsing",
+        "CREATIVE EXPANSION: Generate innovative test scenarios beyond obvious cases",
+        "HYPOTHESIS RIGOR: Base all hypotheses on concrete evidence from analysis",
+        "RISK PRIORITIZATION: Focus on high-impact, high-probability test scenarios"
+      ],
+      "validationCriteria": [
+        { "type": "regex", "pattern": "hypothesis|test case|scenario", "flags": "i", "message": "Output must contain test hypotheses or scenarios" }
+      ],
+      "hasValidation": true
+    },
+    {
+      "id": "phase-3-gap-check",
+      "title": "Phase 3 Gap Check",
+      "prompt": "Quick gap check before scenario generation. If new gaps detected, append to openQuestions and run questioning loop once.",
+      "runCondition": { "or": [ { "var": "newGapsDetected", "equals": true }, { "var": "newGapsDetected", "equals": false } ] }
+    },
+    {
+      "id": "phase-3-progressive-test-generation",
+      "runCondition": {
+        "and": [
+          { "or": [ { "var": "completenessScore", "gte": 0.7 }, { "var": "assumptionAccepted", "equals": true } ] },
+          { "var": "evidenceScore", "gte": 7.5 },
+          { "var": "criteriaCoverage", "gte": 0.7 },
+          { "var": "docNoiseRatio", "lte": 0.3 },
+          { "var": "ticketSpecificEvidenceScore", "gte": 7.0 }
+        ]
+      },
+      "title": "Phase 3: Progressive Test Scenario Generation",
+      "prompt": "progressiveExpansion(validated hypotheses, user experience level)\n\n**PROGRESSIVE TEST EXPANSION ARCHITECTURE**\nGenerate layered test scenarios: Core→Edge→System→Chaos, adapted to user experience level.\n\nadaptToUserLevel(test scenario complexity, user experience level)\n\nupdateTestContext(test-scenarios, layered test scenarios with traceability)\n\n**OUTPUT**: Comprehensive test scenarios adapted to user capabilities.",
+      "agentRole": "You are a progressive test design architect specializing in creating layered test scenarios that scale with team expertise. Your role is to generate comprehensive test coverage while adapting complexity to user capabilities.",
+      "guidance": [
+        "LAYERED APPROACH: Build test scenarios in progressive complexity layers",
+        "ADAPTIVE COMPLEXITY: Match scenario depth to user experience level",
+        "COMPREHENSIVE COVERAGE: Ensure all critical paths are tested",
+        "PRACTICAL IMPLEMENTATION: Include setup, execution, and cleanup details"
+      ]
+    },
+    {
+      "id": "phase-4-confidence-scoring",
+      "runCondition": {
+        "and": [
+          { "or": [ { "var": "completenessScore", "gte": 0.7 }, { "var": "assumptionAccepted", "equals": true } ] },
+          { "var": "evidenceScore", "gte": 7.5 },
+          { "var": "criteriaCoverage", "gte": 0.7 },
+          { "var": "docNoiseRatio", "lte": 0.3 },
+          { "var": "ticketSpecificEvidenceScore", "gte": 7.0 }
+        ]
+      },
+      "title": "Phase 4: Confidence Scoring & Quality Validation",
+      "prompt": "scoreConfidence(generated test cases, evidence base) and validateCoverage(scenarios, requirements)\n\n**CONFIDENCE SCORING FRAMEWORK**\nApply mathematical confidence framework using 4-factor scoring: Requirements Clarity, System Context, Evidence Quality, Coverage Completeness.\n\nscoreAndValidate(test scenarios, confidence criteria)\n\nupdateTestContext(confidence-analysis, scored scenarios with coverage gaps)\n\n**OUTPUT**: Confidence-scored test scenarios with coverage analysis and gap recommendations.",
+      "agentRole": "You are a test quality assurance specialist with expertise in confidence scoring and coverage analysis. Your role is to objectively assess test scenario quality and ensure comprehensive coverage of requirements.",
+      "guidance": [
+        "OBJECTIVE SCORING: Use mathematical framework for consistent confidence assessment",
+        "COVERAGE ANALYSIS: Systematically map test scenarios to requirements",
+        "GAP IDENTIFICATION: Actively identify and address coverage gaps",
+        "QUALITY GATES: Apply appropriate thresholds based on automation preferences"
+      ],
+      "validationCriteria": [
+        { "type": "regex", "pattern": "confidence|score|coverage", "flags": "i", "message": "Output must include confidence scoring and coverage analysis" }
+      ],
+      "hasValidation": true
+    },
+    {
+      "id": "phase-5-dual-format-output",
+      "runCondition": {
+        "and": [
+          { "or": [ { "var": "completenessScore", "gte": 0.7 }, { "var": "assumptionAccepted", "equals": true } ] },
+          { "var": "evidenceScore", "gte": 7.5 },
+          { "var": "criteriaCoverage", "gte": 0.7 },
+          { "var": "docNoiseRatio", "lte": 0.3 },
+          { "var": "ticketSpecificEvidenceScore", "gte": 7.0 }
+        ]
+      },
+      "title": "Phase 5: Dual-Format Output Generation",
+      "prompt": "formatDualOutput(validated test scenarios) - Generate both human-readable and LLM-consumable formats\n\n**DUAL-FORMAT GENERATION STRATEGY**\n\n**FORMAT 1: Human-Readable (Developer-Optimized)**\nClear, scannable format for manual review and JIRA integration:\n- Test scenarios with objectives, preconditions, steps, expected results\n- Priority levels and confidence scores\n- Proper markdown formatting for JIRA copy-paste\n- Traceability links to requirements\n\n**FORMAT 2: LLM-Readable (Machine-Optimized)**\nJSON format optimized for programmatic consumption:\n- Structured metadata with generation info and confidence thresholds\n- Test scenarios with IDs, types, priorities, and confidence scores\n- Requirements mapping and test data specifications\n- Tags for categorization and tool integration\n\n**SIMULTANEOUS GENERATION**\n- Generate both formats from the same source data\n- Ensure consistency between formats\n- Validate format integrity and completeness\n- Optimize for different consumption patterns\n\n**OUTPUT**: Complete test scenarios in both human-readable and machine-readable formats, ready for JIRA integration and future automation",
+      "agentRole": "You are a dual-format output specialist with expertise in creating documentation optimized for both human consumption and machine processing. Your role is to generate test scenarios that serve both immediate manual use and future automation needs.",
+      "guidance": [
+        "DUAL OPTIMIZATION: Create formats optimized for different consumption patterns",
+        "CONSISTENCY MAINTENANCE: Ensure both formats contain identical information",
+        "JIRA INTEGRATION: Format human-readable output for easy ticket integration",
+        "AUTOMATION READY: Structure machine-readable output for future tool consumption"
+      ],
+      "requireConfirmation": true
+    }
+  ]
+}
+
+